@saltcorn/data 0.6.1-beta.3 → 0.6.2-beta.2

package/tests/field.test.js

@@ -1,253 +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"));
-
-afterAll(db.close);
-
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-describe("Field", () => {
-  it("should add and then delete required field", async () => {
-    const patients = await Table.findOne({ name: "patients" });
-    const fc = await Field.create({
-      table: patients,
-      label: "Height1",
-      type: "Integer",
-      required: true,
-      attributes: { default: 6 },
-    });
-    expect(fc.id > 0).toBe(true);
-    const f = await Field.findOne({ id: fc.id });
-    expect(f.name).toBe("height1");
-    expect(f.toJson.name).toBe("height1");
-    expect(f.listKey).toBe("height1");
-    expect(f.presets).toBe(null);
-    await f.delete();
-    const fs = await Field.find({ name: "height1" });
-    expect(fs.length).toBe(0);
-  });
-  it("should add and then delete nonrequired field", async () => {
-    const patients = await Table.findOne({ name: "patients" });
-    const fc = await Field.create({
-      table: patients,
-      name: "Height11",
-      label: "height11",
-      type: "Integer",
-      required: false,
-    });
-    expect(fc.id > 0).toBe(true);
-    const f = await Field.findOne({ id: fc.id });
-
-    await f.delete();
-    const fs = await Field.find({ name: "Height11" });
-    expect(fs.length).toBe(0);
-  });
-  it("creates file field", async () => {
-    const patients = await Table.findOne({ name: "patients" });
-    const fc = await Field.create({
-      table: patients,
-      name: "pic",
-      label: "pic",
-      type: "File",
-      required: false,
-    });
-    expect(fc.reftable_name).toBe("_sc_files");
-  });
-  it("fills fkey options", async () => {
-    const f = await Field.findOne({ name: "favbook" });
-    await f.fill_fkey_options();
-    expect(f.options).toContainEqual({ label: "Leo Tolstoy", value: 2 });
-    if (db.isSQLite) expect(f.sql_type).toBe('int references "books" ("id")');
-    else expect(f.sql_type).toBe('int references "public"."books" ("id")');
-
-    expect(f.is_fkey).toBe(true);
-    expect(f.sql_bare_type).toBe("int");
-  });
-  it("generates fkeys", async () => {
-    const f = await Field.findOne({ name: "favbook" });
-    const v = await f.generate();
-    expect(typeof v).toBe("number");
-  });
-});
-
-describe("validate field", () => {
-  const field = new Field({
-    name: "age",
-    label: "Age",
-    type: "Integer",
-  });
-  expect(field.form_name).toBe("age");
-
-  const res = field.validate({ age: 17 });
-  expect(res).toStrictEqual({ success: 17 });
-});
-describe("generate ", () => {
-  it("color is string", async () => {
-    const field = new Field({
-      name: "col",
-      label: "col",
-      type: "Color",
-    });
-    const rnd = await field.generate();
-    expect(typeof rnd).toBe("string");
-  });
-  it("int not nan", async () => {
-    const field = new Field({
-      name: "x",
-      label: "x",
-      type: "Integer",
-      attributes: { max: 5 },
-    });
-    const rnd = await field.generate();
-    expect(typeof rnd).toBe("number");
-    expect(isNaN(rnd)).toBe(false);
-  });
-});
-describe("validate fkey field", () => {
-  const field = new Field({
-    name: "age",
-    label: "Age",
-    type: "Key to Foos",
-  });
-  expect(field.form_name).toBe("age");
-
-  const res = field.validate({ age: 17 });
-  expect(res).toStrictEqual({ success: 17 });
-});
-
-describe("validate bool field", () => {
-  const field = new Field({
-    name: "over_age",
-    label: "Over age",
-    type: "Bool",
-  });
-  expect(field.form_name).toBe("over_age");
-
-  const res = field.validate({ over_age: "on" });
-  expect(res).toStrictEqual({ success: true });
-  const res1 = field.validate({});
-  expect(res1).toStrictEqual({ success: false });
-});
-
-describe("validate parent field", () => {
-  const field = new Field({
-    name: "age",
-    label: "Age",
-    parent_field: "person",
-    type: "Integer",
-  });
-  expect(field.form_name).toBe("person_age");
-
-  const res = field.validate({ person_age: 17 });
-  expect(res).toStrictEqual({ success: 17 });
-});
-
-describe("validate parent field", () => {
-  const field = new Field({
-    name: "over_age",
-    label: "Over age",
-    type: "Bool",
-    parent_field: "person",
-  });
-  expect(field.form_name).toBe("person_over_age");
-
-  const res = field.validate({ person_over_age: "on" });
-  expect(res).toStrictEqual({ success: true });
-  const res1 = field.validate({});
-  expect(res1).toStrictEqual({ success: false });
-});
-
-describe("validator", () => {
-  const field = new Field({
-    label: "Age",
-    type: "Integer",
-    validator: (x) => false,
-  });
-  const res = field.validate({ age: 17 });
-  expect(res).toStrictEqual({ error: "Not accepted" });
-});
-
-describe("user presets", () => {
-  const field = new Field({
-    label: "User",
-    type: "Key to users",
-  });
-  const presets = field.presets;
-  expect(presets.LoggedIn({ user: { id: 5 } })).toBe(5);
-});
-
-describe("Field.distinct_values", () => {
-  it("gives string options", async () => {
-    const table = await Table.create("fdvtable");
-    const fc = await Field.create({
-      table,
-      label: "Colour",
-      type: "String",
-      required: true,
-      attributes: { options: "Red,Green,Purple" },
-    });
-    const dvs = await fc.distinct_values();
-    expect(dvs).toEqual([
-      { label: "", value: "" },
-      { label: "Red", value: "Red" },
-      { label: "Green", value: "Green" },
-      { label: "Purple", value: "Purple" },
-    ]);
-  });
-
-  it("gives int values", async () => {
-    const table = await Table.findOne({ name: "fdvtable" });
-
-    const fc = await Field.create({
-      table,
-      name: "height",
-      label: "Height",
-      type: "Integer",
-      required: false,
-    });
-    await table.insertRow({ colour: "Red", height: 6 });
-    await table.insertRow({ colour: "Green", height: 11 });
-    const dvs = await fc.distinct_values();
-    expect(dvs).toEqual([
-      { label: "", value: "" },
-      { label: "6", value: 6 },
-      { label: "11", value: 11 },
-    ]);
-    const red_dvs = await fc.distinct_values(null, { colour: "Red" });
-    expect(red_dvs).toEqual([
-      { label: "", value: "" },
-      { label: "6", value: 6 },
-    ]);
-  });
-  it("gives fkey values", async () => {
-    const fc = await Field.findOne({ name: "favbook" });
-    const dvs = await fc.distinct_values();
-    expect(dvs).toEqual([
-      { label: "", value: "" },
-      { label: "Herman Melville", value: 1 },
-      { label: "Leo Tolstoy", value: 2 },
-    ]);
-    const longdvs = await fc.distinct_values(null, { pages: 967 });
-    expect(longdvs).toEqual([
-      { label: "", value: "" },
-      { label: "Herman Melville", value: 1 },
-    ]);
-  });
-  it("gives string values", async () => {
-    const books = await Table.findOne({ name: "books" });
-    await books.insertRow({ author: "Herman Melville", pages: 56 });
-    const fc = await Field.findOne({ name: "author" });
-    const dvs = await fc.distinct_values();
-    expect(dvs).toEqual([
-      { label: "", value: "" },
-      { label: "Herman Melville", value: "Herman Melville" },
-      { label: "Leo Tolstoy", value: "Leo Tolstoy" },
-    ]);
-  });
-});

package/tests/form.test.js

@@ -1,198 +0,0 @@
-const Table = require("../models/table");
-const Field = require("../models/field");
-const FieldRepeat = require("../models/fieldrepeat");
-const Form = require("../models/form");
-const { renderForm } = require("@saltcorn/markup");
-
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-
-const mkRepForm = () =>
-  new Form({
-    action: "/",
-    fields: [
-      new Field({
-        name: "subject",
-        label: "Subject",
-        type: "String",
-      }),
-      new FieldRepeat({
-        name: "students",
-        fields: [
-          new Field({
-            name: "name",
-            label: "Name",
-            type: "String",
-          }),
-          new Field({
-            name: "age",
-            label: "Age",
-            type: "Integer",
-            attributes: { min: 16 },
-          }),
-        ],
-      }),
-    ],
-  });
-
-describe("Form", () => {
-  it("should render", async () => {
-    const form = new Form({
-      action: "/",
-      fields: [
-        new Field({
-          name: "age",
-          label: "Age",
-          type: "Integer",
-          attributes: { min: 16 },
-        }),
-      ],
-    });
-    const html = renderForm(form, "");
-    form.validate({ age: 32 });
-    expect(html.includes("<form")).toBe(true);
-    expect(html.includes('min="16"')).toBe(true);
-    expect(form.values.age).toBe(32);
-  });
-
-  it("should render with repeats", async () => {
-    const form = mkRepForm();
-    const html = renderForm(form, "");
-    form.validate({
-      subject: "Maths",
-      age_0: 18,
-      name_0: "Fred",
-      age_1: 19,
-      name_1: "George",
-    });
-    expect(html.includes("<form")).toBe(true);
-    expect(html.includes('name="age_0"')).toBe(true);
-    expect(form.values.subject).toBe("Maths");
-    expect(form.values.students.length).toBe(2);
-    expect(form.values.students[0].name).toBe("Fred");
-    expect(form.values.students[1].age).toBe(19);
-  });
-  it("should render with repeats and values", async () => {
-    const form = mkRepForm();
-
-    form.values = {
-      subject: "Maths",
-      students: [
-        { name: "Fred", age: 18 },
-        { name: "George", age: 19 },
-      ],
-    };
-    const html = renderForm(form, "");
-    expect(html.includes("<form")).toBe(true);
-    expect(html.includes('name="age_0"')).toBe(true);
-    expect(html.includes('name="name_1"')).toBe(true);
-    expect(html.includes("Fred")).toBe(true);
-    expect(html.includes("George")).toBe(true);
-  });
-  it("should run form validator", async () => {
-    const form = new Form({
-      action: "/",
-      validator({ age }) {
-        if (age < 18) return "Should be older than 18";
-      },
-      fields: [
-        new Field({
-          name: "age",
-          label: "Age",
-          type: "Integer",
-          attributes: { min: 16 },
-        }),
-      ],
-    });
-    const vres = form.validate({ age: 15 });
-    expect(vres.errors).toEqual({ age: "Must be 16 or higher" });
-
-    const vres1 = form.validate({ age: 17 });
-    expect(vres1.errors).toEqual({ _form: "Should be older than 18" });
-  });
-});
-
-describe("Bool Form", () => {
-  const form = new Form({
-    action: "/",
-    fields: [
-      new Field({
-        name: "done",
-        label: "Done",
-        type: "Bool",
-      }),
-    ],
-  });
-  form.validate({ done: "off" });
-  expect(form.values.done).toBe(false);
-  form.validate({});
-  expect(form.values.done).toBe(false);
-  form.validate({ done: "on" });
-  expect(form.values.done).toBe(true);
-});
-
-describe("parent field", () => {
-  const form = new Form({
-    action: "/",
-    fields: [
-      new Field({
-        name: "age",
-        label: "Age",
-        parent_field: "person",
-        type: "Integer",
-      }),
-    ],
-  });
-  const html = renderForm(form, "");
-  expect(html.includes("<form")).toBe(true);
-  expect(html.includes('name="person_age"')).toBe(true);
-  form.validate({ person_age: 16 });
-  expect(form.values.age).toBe(undefined);
-  expect(!!form.values.person).toBe(true);
-  expect(form.values.person.age).toBe(16);
-});
-
-describe("String form with validator failure ", () => {
-  const form = new Form({
-    action: "/",
-    fields: [
-      new Field({
-        name: "name",
-        label: "Name",
-        type: "String",
-        validator(s) {
-          if (s.length < 3) return "Too short";
-        },
-      }),
-    ],
-  });
-  const html = renderForm(form, "");
-  expect(html.includes("<form")).toBe(true);
-  form.validate({ name: "Si" });
-  expect(form.errors).toStrictEqual({ name: "Too short" });
-  expect(form.values).toStrictEqual({ name: "Si" });
-  expect(form.hasErrors).toBe(true);
-});
-
-describe("String form with validator success", () => {
-  const form = new Form({
-    action: "/",
-    fields: [
-      new Field({
-        name: "name",
-        label: "Name",
-        type: "String",
-        validator(s) {
-          if (s.length < 3) return "Too short";
-        },
-      }),
-    ],
-  });
-  const html = renderForm(form, "");
-  expect(html.includes("<form")).toBe(true);
-
-  form.validate({ name: "Simon" });
-  expect(form.values.name).toBe("Simon");
-  expect(form.errors).toStrictEqual({});
-  expect(form.hasErrors).toBe(false);
-});

package/tests/mocks.js

@@ -1,173 +0,0 @@
-const File = require("../models/file");
-const fs = require("fs").promises;
-const Workflow = require("../models/workflow");
-const db = require("../db");
-const { input } = require("@saltcorn/markup/tags");
-const { json_list_to_external_table } = require("../plugin-helper");
-const { sleep } = require("../utils");
-const rick_file = async () => {
-  await File.ensure_file_store();
-
-  const mv = async (fnm) => {
-    await fs.writeFile(fnm, "nevergonnagiveyouup");
-  };
-  return await File.from_req_files(
-    { mimetype: "image/png", name: "rick.png", mv, size: 245752 },
-    1,
-    10
-  );
-};
-const configuration_workflow = () =>
-  new Workflow({
-    steps: [
-      {
-        name: "step1",
-        form: (context) =>
-          new Form({
-            fields: [
-              {
-                name: "first_name",
-                label: "First name",
-                type: "String",
-                required: true,
-              },
-            ],
-          }),
-      },
-      {
-        name: "step2",
-        form: (context) =>
-          new Form({
-            fields: [
-              {
-                name: "last_name",
-                label: "Last name",
-                type: "String",
-                required: true,
-              },
-            ],
-          }),
-      },
-    ],
-  });
-let actionCounter = 1;
-const getActionCounter = () => actionCounter;
-const resetActionCounter = () => {
-  actionCounter = 0;
-};
-const plugin_with_routes = {
-  sc_plugin_api_version: 1,
-  onLoad: async () => {
-    if (!db.isSQLite)
-      await db.query('create extension if not exists "uuid-ossp";');
-  },
-  external_tables: {
-    exttab: json_list_to_external_table(() => [{ name: "Sam", age: 56 }], [
-      { name: "name", type: "String" },
-      { name: "age", type: "Integer" },
-    ]),
-  },
-  types: [
-    {
-      name: "UUID",
-      sql_name: "uuid",
-      primaryKey: { default_sql: "uuid_generate_v4()" },
-      fieldviews: {
-        show: { isEdit: false, run: (v) => v || "" },
-        editHTML: {
-          isEdit: true,
-          run: (nm, v, attrs, cls, required, field) =>
-            input({
-              type: "text",
-              disabled: attrs.disabled,
-              class: ["form-control", cls],
-              "data-fieldname": field.name,
-              name: nm,
-              id: `input${nm}`,
-              value: v || "",
-            }),
-        },
-      },
-      read: (v) => {
-        switch (typeof v) {
-          case "string":
-            return v;
-          default:
-            return undefined;
-        }
-      },
-    },
-  ],
-  actions: {
-    incrementCounter: {
-      run: () => {
-        actionCounter += 1;
-      },
-    },
-    setCounter: {
-      configFields: [{ name: "number", type: "Int" }],
-      run: ({ configuration: { number } }) => {
-        actionCounter = number;
-      },
-    },
-  },
-  functions: {
-    add3: { run: (x) => x + 3 },
-    add5: (x) => x + 5,
-    asyncAdd2: {
-      run: async (x) => {
-        return x + 2;
-      },
-      isAsync: true,
-    },
-  },
-  viewtemplates: [
-    {
-      name: "ViewWithRoutes",
-      display_state_form: false,
-      get_state_fields() {
-        return [];
-      },
-      configuration_workflow,
-      run: async () => {},
-      routes: {
-        the_json_route: async () => {
-          return { json: { success: "ok" } };
-        },
-        the_html_route: async () => {
-          return { html: "<div>Hello</div>" };
-        },
-        the_null_route: () => null,
-      },
-    },
-    {
-      name: "TablelessView",
-      display_state_form: false,
-      tableless: true,
-      get_state_fields() {
-        return [];
-      },
-      configuration_workflow,
-      run: async () => {},
-    },
-  ],
-};
-const mockReqRes = {
-  req: {
-    csrfToken: () => "",
-    getLocale: () => "en",
-    __: (s) => s,
-    user: { id: 1, role_id: 1 },
-  },
-  res: { redirect() {}, json() {}, send() {}, __: (s) => s },
-};
-
-module.exports = {
-  rick_file,
-  plugin_with_routes,
-  configuration_workflow,
-  mockReqRes,
-  getActionCounter,
-  resetActionCounter,
-  sleep,
-};