@truedat/df 8.13.5 → 8.13.7

package/src/templates/components/templateForm/__tests__/dateRestrictionsValidation.spec.js

@@ -0,0 +1,166 @@
+import {
+  parseContentValidation,
+  validateDateRestrictions,
+} from "../contentValidation";
+
+const dateField = (restrictions, type = "date") => ({
+  name: "fecha",
+  label: "Fecha",
+  type,
+  widget: type,
+  cardinality: "?",
+  restrictions,
+});
+
+const parseField = (field) =>
+  parseContentValidation([{ name: "group", fields: [field] }])[0].fields[0];
+
+describe("validateDateRestrictions", () => {
+  it.each([
+    [
+      "an empty static minimum",
+      { min_date: { mode: "static", value: "" } },
+      "min_date.value",
+      "required",
+    ],
+    [
+      "an impossible static maximum",
+      { max_date: { mode: "static", value: "2026-02-30" } },
+      "max_date.value",
+      "invalid_date",
+    ],
+    [
+      "an empty static range start",
+      { between: { mode: "static", start: "", end: "2026-12-31" } },
+      "between.start",
+      "required",
+    ],
+    [
+      "an empty static range end",
+      { between: { mode: "static", start: "2026-01-01", end: "" } },
+      "between.end",
+      "required",
+    ],
+    [
+      "a reversed static range",
+      { between: { mode: "static", start: "2026-12-31", end: "2026-01-01" } },
+      "between.end",
+      "invalid_order",
+    ],
+    [
+      "an incomplete relative minimum",
+      { min_date: { mode: "dynamic", amount: "", unit: "days" } },
+      "min_date.amount",
+      "invalid_amount",
+    ],
+    [
+      "a fractional relative amount",
+      { max_date: { mode: "dynamic", amount: "1.5", unit: "days" } },
+      "max_date.amount",
+      "invalid_amount",
+    ],
+    [
+      "an unsupported relative unit",
+      { max_date: { mode: "dynamic", amount: 1, unit: "hours" } },
+      "max_date.unit",
+      "invalid_unit",
+    ],
+    [
+      "a relative range with its start after its end",
+      {
+        between: {
+          mode: "dynamic",
+          from: { amount: 5, unit: "days" },
+          to: { amount: -2, unit: "days" },
+        },
+      },
+      "between.to.amount",
+      "invalid_order",
+    ],
+  ])(
+    "reports %s at the corresponding field",
+    (_name, restrictions, path, error) => {
+      expect(validateDateRestrictions(dateField(restrictions))[path]).toBe(
+        `template.field.restrictions.validation.${error}`,
+      );
+    },
+  );
+
+  it("accepts a valid static datetime range", () => {
+    expect(
+      validateDateRestrictions(
+        dateField(
+          {
+            between: {
+              mode: "static",
+              start: "2026-10-25T01:30",
+              end: "2026-10-25T02:30",
+            },
+          },
+          "datetime",
+        ),
+      ),
+    ).toEqual({});
+  });
+
+  it("rejects an invalid time and an invalid timezone offset", () => {
+    expect(
+      validateDateRestrictions(
+        dateField(
+          {
+            max_date: { mode: "static", value: "2026-10-25T25:30" },
+          },
+          "datetime",
+        ),
+      )["max_date.value"],
+    ).toBe("template.field.restrictions.validation.invalid_date");
+    expect(
+      validateDateRestrictions(
+        dateField(
+          {
+            max_date: { mode: "static", value: "2026-10-25T02:30+25:00" },
+          },
+          "datetime",
+        ),
+      )["max_date.value"],
+    ).toBe("template.field.restrictions.validation.invalid_date");
+  });
+
+  it("does not report errors when no restriction is selected", () => {
+    expect(validateDateRestrictions(dateField({}))).toEqual({});
+  });
+
+  it("marks the field and its group invalid when a restriction is incomplete", () => {
+    const validated = parseField(
+      dateField({ between: { mode: "static", start: "", end: "2026-12-31" } }),
+    );
+
+    expect(validated.errors).toEqual(
+      expect.objectContaining({
+        hasErrors: true,
+        restrictions: {
+          "between.start": "template.field.restrictions.validation.required",
+        },
+      }),
+    );
+  });
+
+  it("reports errors for dynamic table date columns", () => {
+    const validated = parseField({
+      ...dateField(undefined),
+      type: "dynamic_table",
+      values: {
+        table_columns: [
+          dateField({
+            min_date: { mode: "dynamic", amount: "", unit: "days" },
+          }),
+        ],
+      },
+    });
+
+    expect(validated.errors.hasErrors).toBe(true);
+    expect(
+      validated.values.table_columns[0].errors.restrictions["min_date.amount"],
+    ).toBe("template.field.restrictions.validation.invalid_amount");
+  });
+});

package/src/templates/components/templateForm/__tests__/defaultValueBounds.spec.js

@@ -0,0 +1,191 @@
+import { screen } from "@testing-library/react";
+import { renderWithIntl as render } from "@truedat/test/renderWithIntl";
+import { DefaultValue } from "../DefaultValue";
+
+const formatMessage = jest.fn(({ id }) => id);
+
+beforeEach(() => formatMessage.mockClear());
+
+const field = (restrictions, defaultValue, type = "date") => ({
+  name: "fecha",
+  label: "Fecha",
+  type,
+  widget: type,
+  cardinality: "?",
+  values: null,
+  restrictions,
+  default: { value: defaultValue, origin: "default" },
+});
+
+const mount = (f) =>
+  render(
+    <DefaultValue
+      defaultField="content[0].fields[0].default"
+      field={f}
+      fieldType={f.type}
+      formatMessage={formatMessage}
+      onChange={jest.fn()}
+    />,
+  );
+
+const range = {
+  between: { mode: "static", start: "2026-01-01", end: "2026-12-31" },
+};
+
+describe("a default inside its own restriction", () => {
+  it("is not marked as an error", () => {
+    const { container } = mount(field(range, "2026-06-01"));
+
+    expect(container.querySelector(".field.error")).toBeNull();
+    expect(
+      screen.queryByText(/default_after_min|default_before_max/),
+    ).toBeNull();
+  });
+
+  it("still bounds the calendar to the restriction", () => {
+    mount(field(range, "2026-06-01"));
+
+    const input = screen.getByPlaceholderText("Date");
+    expect(input).toHaveAttribute("min", "2026-01-01");
+    expect(input).toHaveAttribute("max", "2026-12-31");
+  });
+});
+
+describe("a default past a maximum", () => {
+  it("is marked as an error", () => {
+    const { container } = mount(field(range, "2027-01-01"));
+
+    expect(container.querySelector(".field.error")).not.toBeNull();
+  });
+
+  it("names the bound it broke, and the bound is the maximum", () => {
+    mount(field(range, "2027-01-01"));
+
+    expect(
+      screen.getByText("template.field.values.default_before_max"),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/default_after_min/)).toBeNull();
+  });
+
+  it("bounds the calendar so the bad date cannot be re-picked", () => {
+    mount(field(range, "2027-01-01"));
+
+    const input = screen.getByPlaceholderText("Date");
+    expect(input).toHaveAttribute("max", "2026-12-31");
+  });
+});
+
+describe("a default before a minimum", () => {
+  it("names the bound it broke, and the bound is the minimum", () => {
+    mount(field(range, "2025-12-31"));
+
+    expect(
+      screen.getByText("template.field.values.default_after_min"),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/default_before_max/)).toBeNull();
+  });
+});
+
+describe("a default that becomes invalid because the restriction changed", () => {
+  it("is caught as soon as the new restriction is applied", () => {
+    mount(
+      field(
+        {
+          between: { mode: "static", start: "2026-01-01", end: "2026-12-31" },
+          resolved: { min: null, max: "2027-12-31" },
+        },
+        "2027-01-01",
+      ),
+    );
+
+    expect(
+      screen.getByText("template.field.values.default_before_max"),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/default_after_min/)).toBeNull();
+  });
+});
+
+describe("a default with no restriction", () => {
+  it("is not bounded and not marked", () => {
+    const { container } = mount(field(undefined, "2027-01-01"));
+
+    const input = screen.getByPlaceholderText("Date");
+    expect(input).not.toHaveAttribute("min");
+    expect(input).not.toHaveAttribute("max");
+    expect(container.querySelector(".field.error")).toBeNull();
+  });
+});
+
+describe("a datetime default", () => {
+  const dtRange = {
+    max_date: { mode: "static", value: "2026-06-30T10:00" },
+  };
+
+  it("is bounded at minute precision", () => {
+    mount(field(dtRange, "2026-06-15T10:30", "datetime"));
+
+    const input = screen.getByPlaceholderText("Date Time");
+    expect(input).toHaveAttribute("max", "2026-06-30T10:00");
+  });
+
+  it("one minute past the bound is marked", () => {
+    const { container } = mount(field(dtRange, "2026-06-30T10:01", "datetime"));
+
+    expect(container.querySelector(".field.error")).not.toBeNull();
+    expect(
+      screen.getByText("template.field.values.default_before_max"),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/default_after_min/)).toBeNull();
+  });
+});
+
+describe("changing the bound keeps reporting the right side", () => {
+  it("a value above the maximum is not reported as below the minimum", () => {
+    mount(
+      field(
+        {
+          min_date: { mode: "static", value: "2026-01-01" },
+          max_date: { mode: "static", value: "2026-06-30" },
+        },
+        "2027-01-01",
+      ),
+    );
+
+    expect(
+      screen.getByText("template.field.values.default_before_max"),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/default_after_min/)).toBeNull();
+  });
+});
+
+describe("bound interpolation parameters", () => {
+  it.each([
+    ["2027-01-01", "default_before_max", "2026-12-31"],
+    ["2025-12-31", "default_after_min", "2026-01-01"],
+  ])(
+    "passes the breached limit for %s to the formatter",
+    (value, key, limit) => {
+      mount(field(range, value));
+
+      expect(formatMessage).toHaveBeenCalledWith(
+        { id: `template.field.values.${key}` },
+        { limit },
+      );
+    },
+  );
+
+  it("passes a datetime limit without losing its time", () => {
+    mount(
+      field(
+        { max_date: { mode: "static", value: "2026-06-30T10:00" } },
+        "2026-06-30T10:01",
+        "datetime",
+      ),
+    );
+
+    expect(formatMessage).toHaveBeenCalledWith(
+      { id: "template.field.values.default_before_max" },
+      { limit: "2026-06-30T10:00" },
+    );
+  });
+});

package/src/templates/components/templateForm/__tests__/defaultValueRestrictions.spec.js

@@ -0,0 +1,175 @@
+import { defaultValueOutOfRange } from "../contentValidation";
+
+const dateField = (restrictions, defaultValue) => ({
+  name: "fecha",
+  label: "Fecha",
+  type: "date",
+  widget: "date",
+  restrictions,
+  default: { value: defaultValue, origin: "default" },
+});
+
+describe("a date field default must satisfy its own restriction", () => {
+  const range = {
+    between: { mode: "static", start: "2026-01-01", end: "2026-12-31" },
+  };
+
+  describe("no violation", () => {
+    it("accepts a default inside the range", () => {
+      expect(defaultValueOutOfRange(dateField(range, "2026-06-01"))).toBe(
+        false,
+      );
+    });
+
+    it("accepts a default exactly on either bound", () => {
+      expect(defaultValueOutOfRange(dateField(range, "2026-01-01"))).toBe(
+        false,
+      );
+      expect(defaultValueOutOfRange(dateField(range, "2026-12-31"))).toBe(
+        false,
+      );
+    });
+
+    it("accepts an absent default", () => {
+      expect(defaultValueOutOfRange(dateField(range, ""))).toBe(false);
+      expect(defaultValueOutOfRange(dateField(range, null))).toBe(false);
+      expect(
+        defaultValueOutOfRange({ ...dateField(range, ""), default: null }),
+      ).toBe(false);
+    });
+
+    it("accepts a field with no restrictions at all", () => {
+      const field = dateField(undefined, "1999-01-01");
+      expect(defaultValueOutOfRange(field)).toBe(false);
+      expect(defaultValueOutOfRange(dateField({}, "1999-01-01"))).toBe(false);
+    });
+
+    it("does not apply to fields that are not dates", () => {
+      const field = {
+        name: "s",
+        label: "S",
+        type: "string",
+        restrictions: range,
+        default: { value: "1999-01-01", origin: "default" },
+      };
+      expect(defaultValueOutOfRange(field)).toBe(false);
+    });
+  });
+
+  describe("violation", () => {
+    it("flags a default before the range", () => {
+      expect(defaultValueOutOfRange(dateField(range, "2025-12-31"))).toBe(true);
+    });
+
+    it("flags a default after the range", () => {
+      expect(defaultValueOutOfRange(dateField(range, "2027-01-01"))).toBe(true);
+    });
+
+    it("flags against a single-sided max_date", () => {
+      const maxOnly = { max_date: { mode: "static", value: "2026-12-31" } };
+      expect(defaultValueOutOfRange(dateField(maxOnly, "2027-01-01"))).toBe(
+        true,
+      );
+      expect(defaultValueOutOfRange(dateField(maxOnly, "2026-01-01"))).toBe(
+        false,
+      );
+    });
+
+    it("flags against a single-sided min_date", () => {
+      const minOnly = { min_date: { mode: "static", value: "2026-01-01" } };
+      expect(defaultValueOutOfRange(dateField(minOnly, "2025-12-31"))).toBe(
+        true,
+      );
+      expect(defaultValueOutOfRange(dateField(minOnly, "2026-06-01"))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("a datetime default is checked at minute precision", () => {
+    const maxAt = { max_date: { mode: "static", value: "2026-06-30T10:00" } };
+    const datetimeField = (restrictions, defaultValue) => ({
+      ...dateField(restrictions, defaultValue),
+      type: "datetime",
+      widget: "datetime",
+    });
+
+    it("accepts the bound's own minute", () => {
+      expect(
+        defaultValueOutOfRange(datetimeField(maxAt, "2026-06-30T10:00")),
+      ).toBe(false);
+    });
+
+    it("flags one minute past it", () => {
+      expect(
+        defaultValueOutOfRange(datetimeField(maxAt, "2026-06-30T10:01")),
+      ).toBe(true);
+    });
+
+    it("does not blank out the whole day of a midnight bound", () => {
+      const midnight = { max_date: { mode: "static", value: "2026-06-30" } };
+      expect(
+        defaultValueOutOfRange(datetimeField(midnight, "2026-06-30T23:59")),
+      ).toBe(false);
+    });
+  });
+
+  describe("multiple cardinality defaults are checked element by element", () => {
+    it("accepts a list where every value is inside the range", () => {
+      expect(
+        defaultValueOutOfRange(dateField(range, ["2026-03-01", "2026-07-01"])),
+      ).toBe(false);
+    });
+
+    it("flags a list where one value is outside", () => {
+      expect(
+        defaultValueOutOfRange(dateField(range, ["2026-03-01", "2027-07-01"])),
+      ).toBe(true);
+    });
+  });
+
+  describe("a relative restriction is resolved live", () => {
+    it("flags a default beyond a relative maximum", () => {
+      const relative = {
+        max_date: { mode: "dynamic", amount: 1, unit: "days" },
+      };
+
+      expect(defaultValueOutOfRange(dateField(relative, "2030-01-01"))).toBe(
+        true,
+      );
+    });
+
+    it("accepts a default inside a relative window", () => {
+      const relative = {
+        min_date: { mode: "dynamic", amount: -1, unit: "years" },
+      };
+      const recent = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .slice(0, 10);
+      expect(defaultValueOutOfRange(dateField(relative, recent))).toBe(false);
+    });
+
+    it("does not compare a past default against a relative maximum", () => {
+      const relative = {
+        max_date: { mode: "dynamic", amount: -1, unit: "days" },
+      };
+      expect(defaultValueOutOfRange(dateField(relative, "2020-01-01"))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("the resolved block that arrived with the template is not trusted", () => {
+    it("stale bounds do not mask an invalid default", () => {
+      const field = dateField(
+        {
+          between: { mode: "static", start: "2026-01-01", end: "2026-12-31" },
+          resolved: { min: null, max: "2027-12-31" },
+        },
+        "2027-06-01",
+      );
+
+      expect(defaultValueOutOfRange(field)).toBe(true);
+    });
+  });
+});