@beinformed/ui 1.65.13 → 1.65.14

package/src/models/attributes/input-constraints/__tests__/BSNConstraint.spec.js

@@ -1,25 +0,0 @@
-import BSNConstraint from "../BSNConstraint";
-
-describe("bSNConstraint", () => {
-  it("bSN checks", () => {
-    const constraint = new BSNConstraint();
-
-    expect(constraint).toBeInstanceOf(BSNConstraint);
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.validate("abcd")).toBeFalsy();
-
-    expect(constraint.validate("177813702")).toBeTruthy();
-
-    expect(constraint.validate("123456789")).toBeFalsy();
-
-    expect(constraint.validate("-177813702")).toBeFalsy();
-    expect(constraint.validate("+177813702")).toBeFalsy();
-    expect(constraint.validate("1a77813702")).toBeFalsy();
-    expect(constraint.validate("177 813 702")).toBeFalsy();
-    expect(constraint.validate("177.813.702")).toBeFalsy();
-
-    expect(constraint.validate("64915207")).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/ConstraintCollection.spec.js

@@ -1,9 +0,0 @@
-import ConstraintCollection from "../ConstraintCollection";
-
-describe("constraintCollection", () => {
-  it("should be able to create an instance of ConstraintCollection", () => {
-    const constraints = new ConstraintCollection();
-
-    expect(constraints).toBeInstanceOf(ConstraintCollection);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/ConstraintModel.spec.js

@@ -1,35 +0,0 @@
-import ConstraintModel from "../ConstraintModel";
-
-describe("constraintModel", () => {
-  it("can create empty model", () => {
-    const constraint = new ConstraintModel();
-
-    expect(constraint).toBeInstanceOf(ConstraintModel);
-    expect(constraint.hasValidation()).toBe(false);
-    expect(constraint.id).toBeUndefined();
-    expect(constraint.defaultMessage).toBe("Missing default message");
-    expect(constraint.parameters).toBeUndefined();
-    expect(constraint.isMandatoryConstraint).toBeFalsy();
-  });
-
-  it("can create a custom constraint", () => {
-    /**
-     */
-    const validate = (value) => value === "test";
-    const constraint = new ConstraintModel(
-      "custom",
-      validate,
-      "Default message",
-      { prop: "value" },
-    );
-
-    expect(constraint.id).toBe("custom");
-    expect(constraint.defaultMessage).toBe("Default message");
-    expect(constraint.parameters).toStrictEqual({ prop: "value" });
-    expect(constraint.hasValidation()).toBeTruthy();
-    expect(constraint.isMandatoryConstraint).toBeFalsy();
-
-    expect(constraint.validate("test")).toBeTruthy();
-    expect(constraint.validate("not test")).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/DateBoundaryConstraint.spec.js

@@ -1,117 +0,0 @@
-import DateBoundaryConstraint from "../DateBoundaryConstraint";
-import {
-  IllegalArgumentException,
-  IllegalStateException,
-} from "../../../../exceptions";
-
-describe("dateBoundaryConstraint", () => {
-  it("dateBoundaryConstraint requires input", () => {
-    const constraint = new DateBoundaryConstraint();
-
-    expect(constraint).toBeInstanceOf(DateBoundaryConstraint);
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(() => {
-      constraint.isExactDate();
-    }).toThrow(IllegalArgumentException);
-    expect(() => {
-      constraint.isBetweenDates();
-    }).toThrow(IllegalArgumentException);
-    expect(() => {
-      constraint.isSameOrAfterMinDate();
-    }).toThrow(IllegalArgumentException);
-    expect(() => {
-      constraint.isSameOrBeforeMaxDate();
-    }).toThrow(IllegalArgumentException);
-
-    expect(() => {
-      constraint.isExactDate("");
-    }).toThrow(IllegalStateException);
-    expect(() => {
-      constraint.isBetweenDates("");
-    }).toThrow(IllegalStateException);
-    expect(() => {
-      constraint.isSameOrAfterMinDate("");
-    }).toThrow(IllegalStateException);
-    expect(() => {
-      constraint.isSameOrBeforeMaxDate("");
-    }).toThrow(IllegalStateException);
-  });
-
-  it("checks for date", () => {
-    const yearConstraint = new DateBoundaryConstraint(
-      "date",
-      "2010-01-01",
-      "2010-12-31",
-      "yyyy-MM-dd",
-    );
-
-    expect(yearConstraint.validate("2009-01-01")).toBeFalsy();
-    expect(yearConstraint.validate("2010-01-01")).toBeTruthy();
-
-    expect(yearConstraint.validate("2009-02-01")).toBeFalsy();
-    expect(yearConstraint.validate("2010-02-01")).toBeTruthy();
-    expect(yearConstraint.validate("2011-02-01")).toBeFalsy();
-
-    expect(yearConstraint.validate("2009-02-01")).toBeFalsy();
-    expect(yearConstraint.validate("2010-01-01")).toBeTruthy();
-    expect(yearConstraint.validate("2010-02-01")).toBeTruthy();
-
-    expect(yearConstraint.validate("2010-01-01")).toBeTruthy();
-    expect(yearConstraint.validate("2010-12-31")).toBeTruthy();
-    expect(yearConstraint.validate("2011-01-01")).toBeFalsy();
-
-    const dayConstraint = new DateBoundaryConstraint(
-      "date",
-      "2010-01-01",
-      "2010-01-01",
-      "yyyy-MM-dd",
-    );
-    expect(dayConstraint.validate("2010-01-01")).toBeTruthy();
-    expect(dayConstraint.validate("2010-01-02")).toBeFalsy();
-  });
-
-  it("dateBoundaryConstraint checks for datetime", () => {
-    const exactDateConstraint = new DateBoundaryConstraint(
-      "datetime",
-      "2020-05-01T08:00:00",
-      "2020-05-01T10:00:00",
-      "dd-MM-yyyy HH:mm:ss",
-    );
-
-    expect(exactDateConstraint.validate("01-04-2020 09:00:00")).toBeFalsy();
-    expect(exactDateConstraint.validate("01-05-2020 09:00:00")).toBeTruthy();
-
-    const betweenDatesConstraint = new DateBoundaryConstraint(
-      "datetime",
-      "2020-05-01T08:00:00",
-      "2020-05-10T10:00:00",
-      "dd-MM-yyyy HH:mm:ss",
-    );
-
-    expect(betweenDatesConstraint.validate("01-05-2020 08:00:00")).toBeTruthy();
-    expect(betweenDatesConstraint.validate("30-04-2020 08:00:00")).toBeFalsy();
-    expect(betweenDatesConstraint.validate("11-05-2020 08:00:00")).toBeFalsy();
-
-    const minDateConstraint = new DateBoundaryConstraint(
-      "datetime",
-      "2020-01-01T08:00:00",
-      null,
-      "dd-MM-yyyy HH:mm:ss",
-    );
-
-    expect(minDateConstraint.validate("01-07-2020 08:00:00")).toBeTruthy();
-    expect(minDateConstraint.validate("01-07-2019 08:00:00")).toBeFalsy();
-
-    const maxDateConstraint = new DateBoundaryConstraint(
-      "datetime",
-      null,
-      "2020-08-17T13:40:46",
-      "dd-MM-yyyy HH:mm:ss",
-    );
-
-    expect(maxDateConstraint.validate("01-07-2020 08:00:00")).toBeTruthy();
-    expect(maxDateConstraint.validate("18-0-2020 08:00:00")).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/DateTimeDateFormatConstraint.spec.js

@@ -1,30 +0,0 @@
-import DateTimeDateFormatConstraint from "../DateTimeDateFormatConstraint";
-
-describe("dateTimeDateFormatConstraint", () => {
-  it("dateTimeDateFormatConstraint checks for date", () => {
-    const constraint = new DateTimeDateFormatConstraint(
-      "dd-MM-yyyy",
-      "dd-mm-jjjj",
-    );
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.DateFormat.InvalidFormat");
-
-    expect(constraint.format).toBe("dd-MM-yyyy");
-
-    expect(constraint.defaultMessage).toBe(
-      "Date must be entered in the format ${format}",
-    );
-    expect(constraint.formatLabel).toBe("dd-mm-jjjj");
-
-    expect(constraint.validate("19-01-2010")).toBe(true);
-    expect(constraint.validate("19-01-2010 13:37")).toBe(false);
-    expect(constraint.validate("2010-01-01 24:05")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-
-    expect(constraint.validate("19-01-21")).toBe(false);
-    expect(constraint.validate("19-01-999")).toBe(false);
-    expect(constraint.validate("19-01-10000")).toBe(false);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/DateTimeTimeFormatConstraint.spec.js

@@ -1,54 +0,0 @@
-import DateTimeTimeFormatConstraint from "../DateTimeTimeFormatConstraint";
-
-describe("dateTimeDateFormatConstraint", () => {
-  it("dateTimeFormatConstraint checks for date", () => {
-    const constraint = new DateTimeTimeFormatConstraint("HH:mm:ss", "hh:mm:ss");
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.TimeFormat.InvalidFormat");
-
-    expect(constraint.format).toBe("HH:mm:ss");
-
-    expect(constraint.defaultMessage).toBe(
-      "Time must be entered in the format ${format}",
-    );
-    expect(constraint.formatLabel).toBe("hh:mm:ss");
-
-    expect(constraint.validate("13:37:01")).toBe(true);
-
-    expect(constraint.validate("13:37")).toBe(false);
-    expect(constraint.validate("19-01-2010")).toBe(false);
-    expect(constraint.validate("19-01-2010 13:37")).toBe(false);
-    expect(constraint.validate("2010-01-01 24:05")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-  });
-
-  it("validates am/pm", () => {
-    const constraint = new DateTimeTimeFormatConstraint(
-      "hh:mm a",
-      "hh:mm am/pm",
-    );
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.TimeFormat.InvalidFormat");
-
-    expect(constraint.format).toBe("hh:mm a");
-    expect(constraint.formatLabel).toBe("hh:mm am/pm");
-
-    expect(constraint.validate("1:37 am")).toBe(true);
-    expect(constraint.validate("1:37 pm")).toBe(true);
-    expect(constraint.validate("1:37 AM")).toBe(true);
-    expect(constraint.validate("1:37 PM")).toBe(true);
-
-    expect(constraint.validate("13:37 PM")).toBe(false);
-    expect(constraint.validate("13:37 PM")).toBe(false);
-
-    expect(constraint.validate("13:37")).toBe(false);
-    expect(constraint.validate("19-01-2010")).toBe(false);
-    expect(constraint.validate("19-01-2010 13:37")).toBe(false);
-    expect(constraint.validate("2010-01-01 24:05")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/DatetimeFormatConstraint.spec.js

@@ -1,79 +0,0 @@
-import DatetimeFormatConstraint from "../DatetimeFormatConstraint";
-
-describe("datetimeFormatConstraint", () => {
-  it("datetimeFormatConstraint checks for datetime", () => {
-    const constraint = new DatetimeFormatConstraint(
-      "datetime",
-      "dd-MM-yyyy HH:mm",
-      "dd-mm-yyyy hh:mm",
-    );
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.DateTime.MissingValue");
-
-    expect(constraint.format).toBe("dd-MM-yyyy HH:mm");
-
-    expect(constraint.defaultMessage).toBe(
-      "Date and time should both be entered",
-    );
-    expect(constraint.formatLabel).toBe("dd-mm-yyyy hh:mm");
-
-    expect(constraint.validate("19-01-2010 13:37")).toBe(true);
-    expect(constraint.validate("2010-01-01 24:05")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-  });
-
-  it("datetimeFormatConstraint checks for datetime with am / pm", () => {
-    const constraint = new DatetimeFormatConstraint(
-      "datetime",
-      "dd-MM-yyyy hh:mm a",
-      "dd-mm-yyyy hh:mm am/pm",
-    );
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.DateTime.MissingValue");
-
-    expect(constraint.format).toBe("dd-MM-yyyy hh:mm a");
-    expect(constraint.formatLabel).toBe("dd-mm-yyyy hh:mm am/pm");
-
-    expect(constraint.validate("19-01-2010 01:37 am")).toBe(true);
-    expect(constraint.validate("19-01-2010 1:37 pm")).toBe(true);
-    expect(constraint.validate("19-01-2010 1:37 AM")).toBe(true);
-    expect(constraint.validate("19-01-2010 1:37 PM")).toBe(true);
-
-    expect(constraint.validate("19-01-2010 13:37 PM")).toBe(false);
-    expect(constraint.validate("19-01-2010 13:37 PM")).toBe(false);
-
-    expect(constraint.validate("19-01-2010 13:37")).toBe(false);
-    expect(constraint.validate("2010-01-01 24:05")).toBe(false);
-
-    expect(constraint.validate("1:37 am")).toBe(false);
-    expect(constraint.validate("13:37")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-  });
-
-  it("datetimeFormatConstraint checks for timestamp", () => {
-    const constraint = new DatetimeFormatConstraint(
-      "timestamp",
-      "dd-MM-yyyy HH:mm:ss.SSS",
-      "dd-mm-yyyy hh:mm:ss.sss",
-    );
-
-    expect(constraint.id).toBe("Constraint.DateTime.MissingValue");
-
-    expect(constraint.format).toBe("dd-MM-yyyy HH:mm:ss.SSS");
-
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.defaultMessage).toBe(
-      "Date and time should both be entered",
-    );
-    expect(constraint.formatLabel).toBe("dd-mm-yyyy hh:mm:ss.sss");
-
-    expect(constraint.validate("19-01-2010 13:37:37.137")).toBe(true);
-    expect(constraint.validate("2010-01-01 15:14:58.2000")).toBe(false);
-    expect(constraint.validate("2010-01-01")).toBe(false);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/FileExtensionConstraint.spec.js

@@ -1,20 +0,0 @@
-import FileExtensionConstraint from "../FileExtensionConstraint";
-
-describe("fileExtensionConstraint", () => {
-  it("fileExtensionConstraint checks", () => {
-    const constraint = new FileExtensionConstraint([
-      {
-        extensions: ["pdf", "epub"],
-        mimeTypes: ["application/pdf", "application/epub+zip"],
-      },
-    ]);
-
-    expect(constraint.hasValidation()).toBe(false);
-    expect(constraint).toBeInstanceOf(FileExtensionConstraint);
-    expect(constraint.id).toBe("Constraint.File.InvalidExtension");
-    expect(constraint.extensions).toBe("pdf, epub");
-    expect(constraint.validate()).toBeTruthy();
-    expect(typeof constraint.defaultMessage).toBe("string");
-    expect(constraint.parameters).toStrictEqual({ extensions: "pdf, epub" });
-  });
-});

package/src/models/attributes/input-constraints/__tests__/FileSizeConstraint.spec.js

@@ -1,53 +0,0 @@
-import FileSizeConstraint from "../FileSizeConstraint";
-
-describe("fileSizeConstraint", () => {
-  it("fileSizeConstraint standard", () => {
-    const constraint = new FileSizeConstraint({
-      fileSize: 10485760,
-      isMaxTotal: false,
-    });
-
-    expect(constraint.hasValidation()).toBe(false);
-
-    expect(constraint).toBeInstanceOf(FileSizeConstraint);
-    expect(constraint.id).toBe("Constraint.File.MaxFileSize");
-    expect(constraint.filesizeConstraint).toStrictEqual({
-      fileSize: 10485760,
-      isMaxTotal: false,
-    });
-
-    expect(constraint.validate()).toBeTruthy();
-    expect(typeof constraint.defaultMessage).toBe("string");
-    expect(constraint.parameters).toStrictEqual({ "max-filesize": "10.00 MB" });
-
-    expect(constraint.filesize).toBe("10.00 MB");
-    expect(constraint.maxTotalFileSize).toBe("0.00 Bytes");
-  });
-
-  it("fileSizeConstraint maxTotalFileSize", () => {
-    const constraint = new FileSizeConstraint({
-      fileSize: 485760,
-      maxTotalFileSize: 10485760,
-      isMaxTotal: true,
-    });
-
-    expect(constraint).toBeInstanceOf(FileSizeConstraint);
-    expect(constraint.id).toBe("Constraint.File.MaxTotalFileSize");
-    expect(constraint.filesizeConstraint).toStrictEqual({
-      fileSize: 485760,
-      maxTotalFileSize: 10485760,
-      isMaxTotal: true,
-    });
-
-    expect(constraint.hasValidation()).toBeFalsy();
-    expect(constraint.validate()).toBeTruthy();
-    expect(typeof constraint.defaultMessage).toBe("string");
-    expect(constraint.parameters).toStrictEqual({
-      "filesize-left": "474.38 KB",
-      "max-total-filesize": "10.00 MB",
-    });
-
-    expect(constraint.filesize).toBe("474.38 KB");
-    expect(constraint.maxTotalFileSize).toBe("10.00 MB");
-  });
-});

package/src/models/attributes/input-constraints/__tests__/IBANConstraint.spec.js

@@ -1,12 +0,0 @@
-import IBANConstraint from "../IBANConstraint";
-
-describe("iBANConstraint", () => {
-  it("iBAN checks", () => {
-    const constraint = new IBANConstraint();
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint).toBeInstanceOf(IBANConstraint);
-    expect(constraint.validate("ongeldigeIBAN")).toBeFalsy();
-    expect(constraint.validate("NL39 RABO 0300 0652 64")).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/MandatoryConstraint.spec.js

@@ -1,14 +0,0 @@
-import MandatoryConstraint from "../MandatoryConstraint";
-
-describe("mandatoryConstraint", () => {
-  it("mandatory checks", () => {
-    const constraint = new MandatoryConstraint();
-
-    expect(constraint).toBeInstanceOf(MandatoryConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.validate("abcd")).toBeTruthy();
-    expect(constraint.validate("")).toBeFalsy();
-    expect(constraint.validate(null)).toBeFalsy();
-    expect(constraint.validate()).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/NumberBoundaryConstraint.spec.js

@@ -1,46 +0,0 @@
-import NumberBoundaryConstraint from "../NumberBoundaryConstraint";
-
-describe("numberBoundaryConstraint", () => {
-  it("retrieves correct id", () => {
-    expect(new NumberBoundaryConstraint().id).toBe(
-      "Constraint.Number.NoBoundaryConstraint",
-    );
-    expect(new NumberBoundaryConstraint(1, 1).id).toBe(
-      "Constraint.Number.InexactNumber",
-    );
-    expect(new NumberBoundaryConstraint(1, 100).id).toBe(
-      "Constraint.Number.OutOfRange",
-    );
-    expect(new NumberBoundaryConstraint(1).id).toBe(
-      "Constraint.Number.BelowMinimum",
-    );
-    expect(new NumberBoundaryConstraint(null, 100).id).toBe(
-      "Constraint.Number.AboveMaximum",
-    );
-  });
-
-  it("numberBoundaryConstraint checks", () => {
-    const betweenConstraint = new NumberBoundaryConstraint(
-      1,
-      1000,
-      ".",
-      ",",
-      "##.00",
-    );
-
-    expect(betweenConstraint.hasValidation()).toBe(true);
-
-    expect(betweenConstraint.isExactNumber(1)).toBeTruthy();
-    expect(betweenConstraint.isExactNumber(2)).toBeFalsy();
-
-    expect(betweenConstraint.isSameOrAboveMinNumber(-1)).toBeFalsy();
-    expect(betweenConstraint.isSameOrAboveMinNumber(1)).toBeTruthy();
-    expect(betweenConstraint.isSameOrAboveMinNumber(2)).toBeTruthy();
-
-    expect(betweenConstraint.isSameOrBelowMaxNumber(1001)).toBeFalsy();
-    expect(betweenConstraint.isSameOrBelowMaxNumber(1000)).toBeTruthy();
-    expect(betweenConstraint.isSameOrBelowMaxNumber(999)).toBeTruthy();
-
-    expect(betweenConstraint.isBetweenNumbers(500)).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/NumberFormatConstraint.spec.js

@@ -1,137 +0,0 @@
-import NumberFormatConstraint from "../NumberFormatConstraint";
-
-describe("numberFormatConstraint", () => {
-  it("numberFormatConstraint checks", () => {
-    const constraint = new NumberFormatConstraint();
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.defaultMessage).toBe("Must be a whole number");
-    expect(constraint.parameters).toStrictEqual({ "max-digits": 0 });
-    expect(constraint.isMandatoryConstraint).toBe(false);
-
-    expect(constraint.validate(-1)).toBe(true);
-    expect(constraint.validate(0)).toBe(true);
-
-    expect(constraint.isInteger(1)).toBe(true);
-    expect(constraint.isInteger("a")).toBe(false);
-
-    expect(constraint.validate("1")).toBe(true);
-    expect(constraint.validate("a")).toBe(false);
-    expect(constraint.validate("-1")).toBe(true);
-
-    expect(constraint.isInteger(Number.MAX_SAFE_INTEGER)).toBe(true);
-    expect(constraint.isInteger(Number.MAX_SAFE_INTEGER + 1)).toBe(true);
-
-    expect(constraint.isInteger(Number.MIN_SAFE_INTEGER)).toBe(true);
-    expect(constraint.isInteger(Number.MIN_SAFE_INTEGER - 1)).toBe(true);
-
-    const betweenConstraint = new NumberFormatConstraint(",", ".", "#.##");
-
-    expect(betweenConstraint.validate("1")).toBe(true);
-    expect(betweenConstraint.validate("a")).toBe(false);
-    expect(betweenConstraint.isValidDecimal(-1)).toBe(true);
-    expect(betweenConstraint.isValidDecimal(1.21)).toBe(true);
-    expect(betweenConstraint.isValidDecimal(1.2231)).toBe(false);
-
-    const constraintZeros = new NumberFormatConstraint(",", ".", 0);
-    expect(constraintZeros.validate(-1)).toBe(true);
-    expect(constraintZeros.validate(0)).toBe(true);
-    expect(constraintZeros.validate(1)).toBe(true);
-
-    const moneyFormat = new NumberFormatConstraint(".", ",", "#.##");
-
-    expect(moneyFormat.validate("1234,00")).toBe(true);
-    expect(moneyFormat.validate("1.234,00")).toBe(true);
-    expect(moneyFormat.validate("1.000.234,00")).toBe(true);
-
-    const smallConstraint = new NumberFormatConstraint(".", ",", "#.######");
-
-    expect(smallConstraint.validate("0,000015")).toBe(true);
-    expect(smallConstraint.validate("0,00000000015")).toBe(false);
-  });
-
-  it("validates if grouping separator exists on correct place", () => {
-    const constraintMinimalFormat = new NumberFormatConstraint(".", ",", "0");
-    expect(constraintMinimalFormat.validate("1000000")).toBe(true);
-    expect(constraintMinimalFormat.validate("1.00.00.00")).toBe(true);
-    expect(constraintMinimalFormat.validate("1.000.000")).toBe(true);
-    expect(constraintMinimalFormat.validate("1000000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1000000.00")).toBe(true);
-    expect(constraintMinimalFormat.validate("1000.000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1000,000.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1.000.000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1,000,000.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1.00.000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1,00,000.00")).toBe(false);
-
-    const onlyDecimal = new NumberFormatConstraint(".", ",", "###.##");
-    expect(onlyDecimal.defaultMessage).toBe(
-      "The value is not correct numeric format",
-    );
-    expect(onlyDecimal.parameters).toStrictEqual({ "max-digits": 2 });
-
-    expect(onlyDecimal.validate("1000000")).toBe(true);
-    expect(onlyDecimal.validate("1.00.00.00")).toBe(true);
-    expect(onlyDecimal.validate("1.000.000")).toBe(true);
-    expect(onlyDecimal.validate("1000000,00")).toBe(true);
-    expect(onlyDecimal.validate("1000000.00")).toBe(true);
-    expect(onlyDecimal.validate("1.000.000,00")).toBe(true);
-    expect(onlyDecimal.validate("1,000,000.00")).toBe(false);
-    expect(onlyDecimal.validate("1000.000,00")).toBe(true);
-    expect(onlyDecimal.validate("1000,000.00")).toBe(true);
-    expect(onlyDecimal.validate("1.00.000,00")).toBe(true);
-    expect(onlyDecimal.validate("1,00,000.00")).toBe(false);
-
-    const moneyFormat = new NumberFormatConstraint(".", ",", "#,##0.00");
-    expect(moneyFormat.validate("1.000.000")).toBe(true);
-    expect(moneyFormat.validate("1.00.00.00")).toBe(true);
-    expect(moneyFormat.validate("1000000,00")).toBe(true);
-    expect(moneyFormat.validate("1000000.00")).toBe(true);
-    expect(moneyFormat.validate("1000.000,00")).toBe(true);
-    expect(moneyFormat.validate("1000,000.00")).toBe(true);
-    expect(moneyFormat.validate("1.000.000,00")).toBe(true);
-    expect(moneyFormat.validate("1,000,000.00")).toBe(false);
-    expect(moneyFormat.validate("1.00.000,00")).toBe(true);
-    expect(moneyFormat.validate("1,00,000.00")).toBe(false);
-
-    const constraintGroupingDot = new NumberFormatConstraint(
-      ".",
-      ",",
-      "##,##.##",
-    );
-    expect(constraintGroupingDot.validate("1000000")).toBe(true);
-    expect(constraintGroupingDot.validate("1.00.00.00")).toBe(true);
-    expect(constraintGroupingDot.validate("1,00,00,00.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1000000,00")).toBe(true);
-    expect(constraintGroupingDot.validate("1000000.00")).toBe(true);
-    expect(constraintGroupingDot.validate("1.000.000,00")).toBe(true);
-    expect(constraintGroupingDot.validate("1,000,000.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1000.000,00")).toBe(true);
-    expect(constraintGroupingDot.validate("1000,000.00")).toBe(true);
-    expect(constraintGroupingDot.validate("1.00.000,00")).toBe(true);
-    expect(constraintGroupingDot.validate("1,00,000.00")).toBe(false);
-
-    const constraintGroupingComma = new NumberFormatConstraint(
-      ",",
-      ".",
-      "##,##.##",
-    );
-    expect(constraintGroupingComma.validate("1000000")).toBe(true);
-    expect(constraintGroupingComma.validate("1.00.00.00")).toBe(false);
-    expect(constraintGroupingComma.validate("1,00,00,00.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1000000,00")).toBe(true);
-    expect(constraintGroupingComma.validate("1000000.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1.000.000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1,000,000.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1000.000,00")).toBe(true);
-    expect(constraintGroupingComma.validate("1000,000.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1.00.000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1,00,000.00")).toBe(true);
-
-    const constraintNoDecimal = new NumberFormatConstraint("", "", "0");
-
-    expect(constraintNoDecimal.validate("1000000")).toBe(true);
-    expect(constraintNoDecimal.validate("1.000.000")).toBe(false);
-    expect(constraintNoDecimal.validate("1.000.000,00")).toBe(false);
-  });
-});