@beinformed/ui 1.65.12 → 1.65.14

package/src/models/attributes/__tests__/DatetimeAttributeModel.spec.js

@@ -1,206 +0,0 @@
-import DatetimeAttributeModel from "../DatetimeAttributeModel";
-import { ATTRIBUTE_WIDTH } from "../../../constants";
-
-describe("datetimeAttributeModel", () => {
-  it("should be able to create an empty DatetimeAttribute object", () => {
-    const attribute = new DatetimeAttributeModel({}, { type: "datetime" });
-
-    expect(attribute).toBeInstanceOf(DatetimeAttributeModel);
-
-    expect(attribute.type).toBe("datetime");
-    expect(attribute.format).toBe("yyyy-MM-dd'T'HH:mm:ss");
-    expect(attribute.getInputValue()).toBe("");
-    expect(attribute.inputvalue).toBe("");
-    expect(attribute.readonlyvalue).toBe("");
-
-    attribute.addConstraints();
-    expect(attribute.constraintCollection).toHaveLength(1);
-  });
-
-  it("should be able to update", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    attribute.update("18-08-2016 13:45");
-    expect(attribute.getInputValue()).toBe("18-08-2016 13:45");
-    expect(attribute.getInitialInputValue("2016-08-18T13:45:23")).toBe(
-      "18-08-2016 13:45",
-    );
-
-    expect(attribute.readonlyvalue).toBe("18-08-2016 13:45");
-
-    attribute.update(null);
-    expect(attribute.getInputValue()).toBe("");
-
-    attribute.update("");
-    expect(attribute.value).toBeNull();
-
-    attribute.update("aaaa");
-    expect(attribute.value).toBe("Invalid Date");
-  });
-
-  it("should be able to handle min and max date in only date format and renders in format", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-        mindate: "2010-10-01T00:00:00",
-        maxdate: "2010-10-31T23:59:59",
-      },
-    );
-
-    attribute.update("18-08-2016 13:45");
-
-    expect(attribute.isValid).toBe(false);
-    expect(attribute.formatValue(attribute.mindate)).toBe("01-10-2010 00:00");
-    expect(attribute.formatValue(attribute.maxdate)).toBe("31-10-2010 23:59");
-  });
-
-  it("should return AttributeWidth for dates", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "date",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-  });
-
-  it("should return AttributeWidth for times", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "time",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-  });
-
-  it("should return AttributeWidth for datetime", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.MEDIUM);
-  });
-
-  it("can validate datetime with datetime format", () => {
-    const datetimeFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(datetimeFormat.validate("19-10-2010 1:45")).toBe(true);
-    expect(datetimeFormat.validate("19-10-2010 13:45")).toBe(true);
-
-    expect(datetimeFormat.validate("19-10-2010")).toBe(false);
-    expect(datetimeFormat.validate("13:45")).toBe(false);
-    expect(datetimeFormat.validate("19-10-2010 1:45 am")).toBe(false);
-  });
-
-  it("can validate datetime with only date format", () => {
-    const dateFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy",
-      },
-    );
-
-    expect(dateFormat.validate("19-10-2010")).toBe(true);
-
-    expect(dateFormat.validate("19-10-2010 1:45")).toBe(false);
-    expect(dateFormat.validate("13:45")).toBe(false);
-    expect(dateFormat.validate("19-10-2010 1:45 am")).toBe(false);
-  });
-
-  it("can validate datetime with datetime am/pm format", () => {
-    const datetimeAmPmFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy hh:mm a",
-      },
-    );
-
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 am")).toBe(true);
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 pm")).toBe(true);
-
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45")).toBe(false);
-    expect(datetimeAmPmFormat.validate("19-10-2010 13:45")).toBe(false);
-  });
-
-  it("can handle old datetime format with ms", () => {
-    const attribute = new DatetimeAttributeModel(
-      { value: "2031-12-21T17:41:21.000" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute.readonlyvalue).toBe("21-12-2031 17:41");
-  });
-
-  it("can handle custom format", () => {
-    const attribute = new DatetimeAttributeModel(
-      { value: "2031-12-21T17:41:21" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm xxx",
-      },
-    );
-    expect(attribute.readonlyvalue).toBe("21-12-2031 17:41 +01:00");
-
-    const attribute2 = new DatetimeAttributeModel(
-      { value: "2031-12-21T17:41:21" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm Z",
-      },
-    );
-    expect(attribute2.readonlyvalue).toBe("21-12-2031 17:41 +01");
-
-    const attribute3 = new DatetimeAttributeModel(
-      { value: "2031-12-21T17:41:21" },
-      {
-        type: "datetime",
-        format: "EEE MMM dd, yyyy h:mma ZZ",
-      },
-    );
-    expect(attribute3.readonlyvalue).toBe("Sun Dec 21, 2031 5:41PM +0100");
-  });
-
-  it("returns date part of formatlabel as placeholder if attribute has date and time", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-        formatlabel: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute.placeholder).toBe("dd-MM-yyyy");
-  });
-
-  it("does NOT contain offset in formdata property", () => {
-    const attribute = new DatetimeAttributeModel(
-      { key: "datetime", value: "2031-12-21T17:41:21" },
-      { type: "datetime" },
-    );
-
-    expect(attribute.formdata).toEqual({ datetime: "2031-12-21T17:41:21" });
-  });
-});

package/src/models/attributes/__tests__/DatetimeAttributeModel_offset.spec.js

@@ -1,345 +0,0 @@
-import DatetimeAttributeModel from "../DatetimeAttributeModel";
-import {
-  ATTRIBUTE_WIDTH,
-  INCLUDE_TIME_OFFSET,
-  setSettings,
-} from "../../../constants";
-import { DateTimeUtil } from "../../../utils";
-
-describe("datetimeAttributeModel with offset on", () => {
-  beforeEach(() => {
-    setSettings({ [INCLUDE_TIME_OFFSET]: true });
-  });
-
-  it("should be able to create an empty DatetimeAttribute object", () => {
-    const attribute = new DatetimeAttributeModel({}, { type: "datetime" });
-
-    expect(attribute).toBeInstanceOf(DatetimeAttributeModel);
-
-    expect(attribute.type).toBe("datetime");
-    expect(attribute.format).toBe("yyyy-MM-dd'T'HH:mm:ssxxx");
-    expect(attribute.getInputValue()).toBe("");
-    expect(attribute.inputvalue).toBe("");
-    expect(attribute.readonlyvalue).toBe("");
-
-    attribute.addConstraints();
-    expect(attribute.constraintCollection).toHaveLength(1);
-  });
-
-  it("should be able to update", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    attribute.update("18-08-2016 13:45 +02:00");
-    expect(attribute.getInputValue()).toBe("18-08-2016 13:45 +02:00");
-    expect(attribute.getInitialInputValue("2016-08-18T13:45:23+02:00")).toBe(
-      "18-08-2016 13:45 +02:00",
-    );
-
-    expect(attribute.readonlyvalue).toBe("18-08-2016 13:45");
-
-    attribute.update(null);
-    expect(attribute.getInputValue()).toBe("");
-
-    attribute.update("");
-    expect(attribute.value).toBeNull();
-
-    attribute.update("aaaa");
-    expect(attribute.value).toBe("Invalid Date");
-  });
-
-  it("should be able to handle min and max date in only date format and renders in format", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-        mindate: "2010-10-01T00:00:00+02:00", // CEST
-        maxdate: "2010-10-31T23:59:59+01:00", // CET
-      },
-    );
-
-    attribute.update("18-08-2016 13:45");
-
-    expect(attribute.isValid).toBe(false);
-    expect(attribute.formatValue(attribute.mindate)).toBe("01-10-2010 00:00");
-    expect(attribute.formatValue(attribute.maxdate)).toBe("31-10-2010 23:59");
-  });
-
-  it("should return AttributeWidth for dates", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "date",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-  });
-
-  it("should return AttributeWidth for times", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "time",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.SMALL);
-  });
-
-  it("should return AttributeWidth for datetime", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-      },
-    );
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.MEDIUM);
-  });
-
-  it("can validate datetime with datetime format", () => {
-    const datetimeFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(datetimeFormat.validate("19-10-2010 1:45 +02:00")).toBe(true);
-    expect(datetimeFormat.validate("19-10-2010 13:45 +02:00")).toBe(true);
-
-    expect(datetimeFormat.validate("19-10-2010")).toBe(false);
-    expect(datetimeFormat.validate("13:45")).toBe(false);
-    expect(datetimeFormat.validate("19-10-2010 1:45 am")).toBe(false);
-  });
-
-  it("can validate datetime with only date format", () => {
-    const dateFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy",
-      },
-    );
-
-    expect(dateFormat.validate("19-10-2010")).toBe(true);
-
-    expect(dateFormat.validate("19-10-2010 1:45")).toBe(false);
-    expect(dateFormat.validate("13:45")).toBe(false);
-    expect(dateFormat.validate("19-10-2010 1:45 am")).toBe(false);
-  });
-
-  it("can validate datetime with datetime am/pm format", () => {
-    const datetimeAmPmFormat = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy hh:mm a",
-      },
-    );
-
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 am +02:00")).toBe(true);
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 pm +02:00")).toBe(true);
-
-    expect(datetimeAmPmFormat.validate("19-10-2010 1:45 +02:00")).toBe(false);
-    expect(datetimeAmPmFormat.validate("19-10-2010 13:45 +02:00")).toBe(false);
-  });
-
-  it("can handle old datetime format with ms", () => {
-    const attribute = new DatetimeAttributeModel(
-      { value: "2031-12-21T17:41:21.000+01:00" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute.readonlyvalue).toBe("21-12-2031 17:41");
-  });
-
-  it("returns date part of formatlabel as placeholder if attribute has date and time", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-        formatlabel: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute.placeholder).toBe("dd-MM-yyyy");
-  });
-
-  it("contains offset in formdata property", () => {
-    const attribute = new DatetimeAttributeModel(
-      { key: "datetime", value: "2031-12-21T17:41:21+01:00" },
-      { type: "datetime" },
-    );
-
-    expect(attribute.formdata).toEqual({
-      datetime: "2031-12-21T17:41:21+01:00",
-    });
-  });
-
-  it("handles offsets and indicates ambiguouty", () => {
-    const winter = new DatetimeAttributeModel(
-      { key: "datetime", value: "2031-12-21T17:41:21+01:00" },
-      { type: "datetime" },
-    );
-
-    expect(winter.isAmbiguous).toBe(false);
-    expect(winter.offset).toEqual({
-      abbr: "CET",
-      label: "Central European Standard Time",
-      value: "+01:00",
-    });
-
-    const summer = new DatetimeAttributeModel(
-      { key: "datetime", value: "2031-07-01T17:41:21+02:00" },
-      { type: "datetime" },
-    );
-
-    expect(summer.isAmbiguous).toBe(false);
-    expect(summer.offset).toEqual({
-      abbr: "CEST",
-      label: "Central European Summer Time",
-      value: "+02:00",
-    });
-
-    const ambiguousSummer = new DatetimeAttributeModel(
-      { key: "datetime", value: "2024-10-27T02:30:00+02:00" },
-      { type: "datetime" },
-    );
-
-    expect(ambiguousSummer.isAmbiguous).toBe(true);
-    expect(ambiguousSummer.offset).toEqual({
-      abbr: "CEST",
-      label: "Central European Summer Time",
-      value: "+02:00",
-    });
-
-    const ambiguousWinter = new DatetimeAttributeModel(
-      { key: "datetime", value: "2024-10-27T02:30:00+01:00" },
-      { type: "datetime" },
-    );
-
-    expect(ambiguousWinter.isAmbiguous).toBe(true);
-    expect(ambiguousWinter.offset).toEqual({
-      abbr: "CET",
-      label: "Central European Standard Time",
-      value: "+01:00",
-    });
-  });
-
-  it("retrieves the correct error collection", () => {
-    const attribute = new DatetimeAttributeModel(
-      {},
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    attribute.inputvalue = "27-10-2024";
-
-    expect(attribute.errorCollection.map((error) => error.id)).toEqual([
-      "Constraint.DateTime.MissingValue",
-    ]);
-
-    attribute.inputvalue = "27-10-2024 02:30";
-
-    expect(attribute.errorCollection.map((error) => error.id)).toEqual([
-      "Constraint.DateTime.MissingOffset",
-    ]);
-
-    attribute.inputvalue = "27-10-2024 +02:00";
-
-    expect(attribute.errorCollection.map((error) => error.id)).toEqual([
-      "Constraint.DateTime.MissingValue",
-    ]);
-  });
-
-  it("handles dst", () => {
-    const attribute1 = new DatetimeAttributeModel(
-      { value: "2024-10-27T01:30:00+00:00" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute1.initvalue).toBe("2024-10-27T02:30:00+01:00");
-    expect(
-      DateTimeUtil.toFormat(attribute1.value, "dd-MM-yyyy HH:mm xxx"),
-    ).toBe("27-10-2024 02:30 +01:00");
-    expect(attribute1.isAmbiguous).toBe(true);
-    expect(attribute1.offset).toEqual({
-      abbr: "CET",
-      label: "Central European Standard Time",
-      value: "+01:00",
-    });
-
-    const attribute2 = new DatetimeAttributeModel(
-      { value: "2024-10-27T00:30:00+00:00" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm",
-      },
-    );
-
-    expect(attribute2.initvalue).toBe("2024-10-27T02:30:00+02:00");
-    expect(
-      DateTimeUtil.toFormat(attribute2.value, "dd-MM-yyyy HH:mm xxx"),
-    ).toBe("27-10-2024 02:30 +02:00");
-    expect(attribute2.isAmbiguous).toBe(true);
-    expect(attribute2.offset).toEqual({
-      abbr: "CEST",
-      label: "Central European Summer Time",
-      value: "+02:00",
-    });
-  });
-
-  it("Date formats", () => {
-    const datetime = new DatetimeAttributeModel(
-      { key: "datetime", value: "1969-09-23T12:34:00+00:00" },
-      {
-        type: "datetime",
-        format: "dd-MM-yyyy HH:mm X",
-      },
-    );
-
-    expect(datetime.format).toBe("dd-MM-yyyy HH:mm X");
-    expect(datetime.dateInputFormat).toBe("dd-MM-yyyy");
-    expect(datetime.timeInputFormat).toBe("HH:mm");
-    expect(datetime.errorCollection.isEmpty).toBe(true);
-
-    const timestamp = new DatetimeAttributeModel(
-      { key: "timestamp", value: "1969-09-23T12:34:00.010+00:00" },
-      {
-        type: "timestamp",
-        format: "dd-MM-yyyy HH:mm:ss.SSS X",
-      },
-    );
-
-    expect(timestamp.format).toBe("dd-MM-yyyy HH:mm:ss.SSS X");
-    expect(timestamp.dateInputFormat).toBe("dd-MM-yyyy");
-    expect(timestamp.timeInputFormat).toBe("HH:mm:ss.SSS");
-
-    const special = new DatetimeAttributeModel(
-      { key: "timestamp", value: "1969-09-23T12:34:00.010+00:00" },
-      {
-        type: "timestamp",
-        format: "'special' do 'de' MMMM yyyy h 'o''clock'",
-      },
-    );
-
-    expect(special.format).toBe("'special' do 'de' MMMM yyyy h 'o''clock'");
-    expect(special.dateInputFormat).toBe("do 'de' MMMM yyyy");
-    // expect(special.timeInputFormat).toBe("HH:mm:ss.SSS");
-  });
-});

package/src/models/attributes/__tests__/HelptextAttributeModel.spec.js

@@ -1,64 +0,0 @@
-import HelptextAttributeModel from "../HelptextAttributeModel";
-
-describe("helptextAttributeModel", () => {
-  it("should be able to create a HelptextAttribute object", () => {
-    const attribute = new HelptextAttributeModel();
-
-    expect(attribute).toBeInstanceOf(HelptextAttributeModel);
-    expect(attribute.type).toBe("helptext");
-    expect(attribute.text).toBeNull();
-
-    const attributeWithText = new HelptextAttributeModel(
-      {
-        key: "CarDetails",
-        content: null,
-        static: true,
-        dynamicschemaId: "CarDetails",
-        isResult: false,
-        children: [],
-      },
-      { text: "Example helptext text" },
-    );
-
-    expect(attributeWithText.text).toBe("Example helptext text");
-  });
-
-  it("should be able to handle content in data", () => {
-    const attributeWithText = new HelptextAttributeModel(
-      {
-        key: "CarDetails",
-        content: {
-          text: {
-            id: "CarDetails.text",
-            properties: {
-              PersonPrivateCar: "Ferrari GTO",
-              PersonLessFavoriteCars: "Mercedes",
-              PersonFavoriteCars: "BMW 5 Series, Fiat Panda",
-            },
-            message:
-              "<p>Currently the person drives in a Ferrari GTO, although his favorite cars are BMW 5 Series, Fiat Panda. Less favorite cars of the person are Mercedes.</p>",
-          },
-        },
-        static: true,
-        dynamicschemaId: "CarDetails",
-        isResult: false,
-        children: [],
-      },
-      {
-        type: "string",
-        label: "Car details",
-        mandatory: false,
-        readonly: true,
-        text: {
-          id: "CarDetails.text",
-          message:
-            "<p>Currently the person drives in a ${PersonPrivateCar}, although his favorite cars are ${PersonFavoriteCars}. Less favorite cars of the person are ${PersonLessFavoriteCars}.</p>",
-        },
-      },
-    );
-
-    expect(attributeWithText.text).toBe(
-      "<p>Currently the person drives in a Ferrari GTO, although his favorite cars are BMW 5 Series, Fiat Panda. Less favorite cars of the person are Mercedes.</p>",
-    );
-  });
-});

package/src/models/attributes/__tests__/LabelAttributeModel.spec.js

@@ -1,13 +0,0 @@
-import LabelAttributeModel from "../LabelAttributeModel";
-import { ATTRIBUTE_WIDTH } from "../../../constants";
-
-describe("labelAttributeModel", () => {
-  it("should be able to create an empty LabelAttribute object", () => {
-    const attribute = new LabelAttributeModel();
-
-    expect(attribute).toBeInstanceOf(LabelAttributeModel);
-    expect(attribute.type).toBe("label");
-
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.MEDIUM);
-  });
-});

package/src/models/attributes/__tests__/LookupAttributeModel.spec.js

@@ -1,47 +0,0 @@
-import LookupAttributeModel from "../ChoiceAttributeModel";
-
-describe("lookupAttributeModel", () => {
-  it("should be able to create an instance of LookupAttributeModel", () => {
-    const lookupAttribute = new LookupAttributeModel();
-
-    expect(lookupAttribute).toBeInstanceOf(LookupAttributeModel);
-
-    expect(lookupAttribute.type).toBe("choice");
-  });
-
-  it("has a lookupLink", () => {
-    const lookupAttribute = new LookupAttributeModel({
-      _links: {
-        lookupOptions: {
-          href: "/lookupOptions?lookupToken=41e23fd5-9a4c-41de-9c19-0ec0d9b3c643",
-        },
-      },
-      optionMode: "lookup",
-    });
-
-    expect(lookupAttribute.type).toBe("choice");
-    expect(lookupAttribute.lookupLink.href.path).toBe("/lookupOptions");
-
-    lookupAttribute.addOption({
-      code: "optionA",
-      label: "Option A",
-      selected: true,
-    });
-
-    expect(lookupAttribute.options).toHaveLength(1);
-    expect(lookupAttribute.options.all[0].selected).toBeTruthy();
-
-    lookupAttribute.addOption({
-      code: "optionA",
-    });
-    expect(lookupAttribute.options).toHaveLength(1);
-
-    lookupAttribute.update("optionB");
-
-    expect(lookupAttribute.options).toHaveLength(1);
-    expect(lookupAttribute.options.all[0].selected).toBeTruthy();
-
-    lookupAttribute.update("optionA");
-    expect(lookupAttribute.options.all[0].selected).toBeFalsy();
-  });
-});

package/src/models/attributes/__tests__/MemoAttributeModel.spec.js

@@ -1,28 +0,0 @@
-import MemoAttributeModel from "../MemoAttributeModel";
-import { ATTRIBUTE_WIDTH } from "../../../constants";
-
-describe("memoAttributeModel", () => {
-  it("should be able to create an empty MemoAttribute object", () => {
-    const attribute = new MemoAttributeModel();
-
-    expect(attribute).toBeInstanceOf(MemoAttributeModel);
-    expect(attribute.type).toBe("memo");
-    expect(attribute.rows).toBe(10);
-    expect(attribute.formatted).toBeFalsy();
-
-    expect(attribute.readonlyWidth).toBe(ATTRIBUTE_WIDTH.LARGE);
-  });
-
-  it("should be able to create a formatted MemoAttribute object", () => {
-    const attribute = new MemoAttributeModel(
-      {},
-      {
-        formatted: true,
-        rows: 5,
-      },
-    );
-
-    expect(attribute.rows).toBe(5);
-    expect(attribute.formatted).toBeTruthy();
-  });
-});