@oneuptime/common 12.0.28 → 12.0.30

package/Tests/Types/Calendar/ICalendar.test.ts

@@ -0,0 +1,488 @@
+import ICalendar, {
+  ICALENDAR_LINE_BREAK,
+  ICALENDAR_MAX_LINE_OCTETS,
+  ICalendarCalendar,
+  ICalendarDocument,
+  ICalendarEvent,
+  ICalendarEventStatus,
+  ICalendarTransparency,
+} from "../../../Types/Calendar/ICalendar";
+import OneUptimeDate from "../../../Types/Date";
+import BadDataException from "../../../Types/Exception/BadDataException";
+
+const at: (iso: string) => Date = (iso: string): Date => {
+  return OneUptimeDate.fromString(iso);
+};
+
+const CRLF: string = "\r\n";
+
+function physicalLines(body: string): Array<string> {
+  const lines: Array<string> = body.split(CRLF);
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+
+function octets(text: string): number {
+  return Buffer.byteLength(text, "utf8");
+}
+
+// A lone surrogate means a UTF-16 pair (= one 4-octet UTF-8 char) was split.
+const LONE_SURROGATE: RegExp =
+  /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+
+function baseCalendar(): ICalendarCalendar {
+  return {
+    productId: "-//Test//Feed//EN",
+    name: "Team",
+    description: "Desc",
+    timezone: "UTC",
+    refreshInterval: "PT1H",
+    lastModified: at("2026-08-01T10:00:00Z"),
+  };
+}
+
+function baseEvent(): ICalendarEvent {
+  return {
+    uid: "u1@test",
+    dtStamp: at("2026-08-01T10:00:00Z"),
+    lastModified: at("2026-08-01T10:00:00Z"),
+    sequence: 2,
+    start: at("2026-09-01T07:00:00Z"),
+    end: at("2026-09-01T15:00:00Z"),
+    summary: "On-call · Team",
+    description: "Line 1\nLine 2; a, b",
+    url: "https://x.test/a",
+    status: ICalendarEventStatus.Confirmed,
+    transparency: ICalendarTransparency.Transparent,
+    categories: ["On-Call"],
+  };
+}
+
+describe("ICalendar.serialize", () => {
+  test("byte-exact snapshot of a small calendar", () => {
+    const body: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [baseEvent()],
+    });
+
+    const expected: string =
+      [
+        "BEGIN:VCALENDAR",
+        "VERSION:2.0",
+        "PRODID:-//Test//Feed//EN",
+        "CALSCALE:GREGORIAN",
+        "NAME:Team",
+        "X-WR-CALNAME:Team",
+        "X-WR-CALDESC:Desc",
+        "X-WR-TIMEZONE:UTC",
+        "REFRESH-INTERVAL;VALUE=DURATION:PT1H",
+        "X-PUBLISHED-TTL:PT1H",
+        "LAST-MODIFIED:20260801T100000Z",
+        "BEGIN:VEVENT",
+        "UID:u1@test",
+        "DTSTAMP:20260801T100000Z",
+        "LAST-MODIFIED:20260801T100000Z",
+        "SEQUENCE:2",
+        "DTSTART:20260901T070000Z",
+        "DTEND:20260901T150000Z",
+        "SUMMARY:On-call · Team",
+        "DESCRIPTION:Line 1\\nLine 2\\; a\\, b",
+        "URL:https://x.test/a",
+        "STATUS:CONFIRMED",
+        "TRANSP:TRANSPARENT",
+        "CATEGORIES:On-Call",
+        "END:VEVENT",
+        "END:VCALENDAR",
+      ].join(CRLF) + CRLF;
+
+    expect(body).toBe(expected);
+  });
+
+  test("every line break is CRLF and the body ends with one", () => {
+    const body: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [baseEvent()],
+    });
+
+    expect(body.endsWith(CRLF)).toBe(true);
+    expect(body.replace(/\r\n/g, "")).not.toContain("\n");
+    expect(body.replace(/\r\n/g, "")).not.toContain("\r");
+    expect(ICALENDAR_LINE_BREAK).toBe(CRLF);
+  });
+
+  test("serializing the same document twice gives identical bytes, whatever the key order", () => {
+    const first: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [baseEvent()],
+    });
+
+    const shuffledEvent: ICalendarEvent = {
+      categories: ["On-Call"],
+      transparency: ICalendarTransparency.Transparent,
+      status: ICalendarEventStatus.Confirmed,
+      url: "https://x.test/a",
+      description: "Line 1\nLine 2; a, b",
+      summary: "On-call · Team",
+      end: at("2026-09-01T15:00:00Z"),
+      start: at("2026-09-01T07:00:00Z"),
+      sequence: 2,
+      lastModified: at("2026-08-01T10:00:00Z"),
+      dtStamp: at("2026-08-01T10:00:00Z"),
+      uid: "u1@test",
+    };
+
+    const second: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [shuffledEvent],
+    });
+
+    expect(second).toBe(first);
+  });
+
+  test("never emits METHOD, CLASS, VALARM, RRULE, VTIMEZONE, ORGANIZER or ATTENDEE", () => {
+    const body: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [baseEvent(), { ...baseEvent(), uid: "u2@test" }],
+    });
+
+    for (const forbidden of [
+      "METHOD",
+      "CLASS",
+      "VALARM",
+      "RRULE",
+      "VTIMEZONE",
+      "ORGANIZER",
+      "ATTENDEE",
+      "TZID",
+    ]) {
+      expect(body).not.toMatch(new RegExp(`^${forbidden}[:;]`, "m"));
+      expect(body).not.toContain(`BEGIN:${forbidden}`);
+    }
+  });
+
+  test("an empty calendar is just the header", () => {
+    const body: string = ICalendar.serialize({
+      calendar: baseCalendar(),
+      events: [],
+    });
+
+    expect(body).not.toContain("BEGIN:VEVENT");
+    expect(physicalLines(body)[0]).toBe("BEGIN:VCALENDAR");
+    expect(physicalLines(body)[physicalLines(body).length - 1]).toBe(
+      "END:VCALENDAR",
+    );
+  });
+
+  test("optional header properties are omitted when absent or empty; X-WR-CALNAME defaults to NAME", () => {
+    const body: string = ICalendar.serialize({
+      calendar: {
+        productId: "-//Test//Feed//EN",
+        name: "Only Name",
+        description: "",
+      },
+      events: [],
+    });
+
+    expect(body).toContain("NAME:Only Name\r\n");
+    expect(body).toContain("X-WR-CALNAME:Only Name\r\n");
+    expect(body).not.toContain("X-WR-CALDESC");
+    expect(body).not.toContain("X-WR-TIMEZONE");
+    expect(body).not.toContain("REFRESH-INTERVAL");
+    expect(body).not.toContain("X-PUBLISHED-TTL");
+    expect(body).not.toContain("LAST-MODIFIED");
+  });
+
+  test("displayName overrides X-WR-CALNAME while NAME keeps the full name", () => {
+    const body: string = ICalendar.serialize({
+      calendar: {
+        productId: "-//Test//Feed//EN",
+        name: "A very long schedule name indeed",
+        displayName: "A very long schedule…",
+      },
+      events: [],
+    });
+
+    expect(body).toContain("NAME:A very long schedule name indeed\r\n");
+    expect(body).toContain("X-WR-CALNAME:A very long schedule…\r\n");
+  });
+
+  test("optional event properties are omitted when absent", () => {
+    const lines: Array<string> = ICalendar.serializeEvent({
+      uid: "bare@test",
+      dtStamp: at("2026-08-01T10:00:00Z"),
+      start: at("2026-09-01T07:00:00Z"),
+      end: at("2026-09-01T15:00:00Z"),
+      summary: "Bare",
+    });
+
+    expect(lines).toEqual([
+      "BEGIN:VEVENT",
+      "UID:bare@test",
+      "DTSTAMP:20260801T100000Z",
+      "DTSTART:20260901T070000Z",
+      "DTEND:20260901T150000Z",
+      "SUMMARY:Bare",
+      "END:VEVENT",
+    ]);
+  });
+
+  test("REFRESH-INTERVAL and X-PUBLISHED-TTL carry the same normalised duration", () => {
+    const body: string = ICalendar.serialize({
+      calendar: { ...baseCalendar(), refreshInterval: " pt15m " },
+      events: [],
+    });
+
+    expect(body).toContain("REFRESH-INTERVAL;VALUE=DURATION:PT15M\r\n");
+    expect(body).toContain("X-PUBLISHED-TTL:PT15M\r\n");
+  });
+
+  test("an invalid refresh interval throws", () => {
+    for (const bad of ["1h", "P", "PT", "PT1X", ""]) {
+      expect(() => {
+        return ICalendar.serialize({
+          calendar: { ...baseCalendar(), refreshInterval: bad },
+          events: [],
+        });
+      }).toThrow(BadDataException);
+    }
+  });
+
+  test("an empty UID, an inverted event or a bad SEQUENCE throws", () => {
+    expect(() => {
+      return ICalendar.serializeEvent({ ...baseEvent(), uid: "  " });
+    }).toThrow(BadDataException);
+
+    expect(() => {
+      return ICalendar.serializeEvent({
+        ...baseEvent(),
+        end: at("2026-09-01T07:00:00Z"),
+      });
+    }).toThrow(BadDataException);
+
+    expect(() => {
+      return ICalendar.serializeEvent({ ...baseEvent(), sequence: -1 });
+    }).toThrow(BadDataException);
+
+    expect(() => {
+      return ICalendar.serializeEvent({ ...baseEvent(), sequence: 1.5 });
+    }).toThrow(BadDataException);
+  });
+
+  test("CATEGORIES escapes each entry and joins with commas; URL is not TEXT-escaped", () => {
+    const lines: Array<string> = ICalendar.serializeEvent({
+      ...baseEvent(),
+      categories: ["On-Call", "a,b", "c;d"],
+      url: "https://x.test/a?b=1,2;3\nrest",
+    });
+
+    expect(lines).toContain("CATEGORIES:On-Call,a\\,b,c\\;d");
+    expect(lines).toContain("URL:https://x.test/a?b=1,2;3rest");
+  });
+});
+
+describe("ICalendar.escapeText", () => {
+  test("escapes backslash, semicolon, comma and newline in that order of precedence", () => {
+    expect(ICalendar.escapeText("a;b,c\\d\ne")).toBe("a\\;b\\,c\\\\d\\ne");
+  });
+
+  test("drops carriage returns and other control characters but keeps tabs", () => {
+    expect(ICalendar.escapeText("x\r\nyz\tw")).toBe("x\\nyz\tw");
+  });
+
+  test("leaves multi-byte characters untouched", () => {
+    expect(ICalendar.escapeText("Ærø · 東京 · 😀")).toBe("Ærø · 東京 · 😀");
+  });
+
+  test("escaping is idempotent on already-plain text and round-trips through a client-style unescape", () => {
+    const original: string = "Who: A\nSchedule: B (C); D, E\\F";
+    const escaped: string = ICalendar.escapeText(original);
+
+    const unescaped: string = escaped.replace(
+      /\\([\\;,nN])/g,
+      (_match: string, char: string): string => {
+        return char === "n" || char === "N" ? "\n" : char;
+      },
+    );
+
+    expect(unescaped).toBe(original);
+  });
+});
+
+describe("ICalendar.formatUtcDateTime", () => {
+  test("formats as YYYYMMDDTHHMMSSZ in UTC, ignoring milliseconds", () => {
+    expect(ICalendar.formatUtcDateTime(at("2026-03-08T06:30:05.999Z"))).toBe(
+      "20260308T063005Z",
+    );
+    expect(ICalendar.formatUtcDateTime(at("2026-12-31T23:59:59Z"))).toBe(
+      "20261231T235959Z",
+    );
+    expect(ICalendar.formatUtcDateTime(at("2026-01-01T00:00:00Z"))).toBe(
+      "20260101T000000Z",
+    );
+  });
+
+  test("zero-pads every component", () => {
+    expect(ICalendar.formatUtcDateTime(at("2026-02-03T04:05:06Z"))).toBe(
+      "20260203T040506Z",
+    );
+  });
+
+  test("throws on an invalid date", () => {
+    expect(() => {
+      return ICalendar.formatUtcDateTime(new Date("not a date"));
+    }).toThrow(BadDataException);
+  });
+});
+
+describe("ICalendar.foldLine", () => {
+  test("a line of at most 75 octets is returned unchanged", () => {
+    const line: string = `SUMMARY:${"a".repeat(67)}`;
+    expect(octets(line)).toBe(75);
+    expect(ICalendar.foldLine(line)).toBe(line);
+  });
+
+  test("a long ASCII line folds into 75-octet pieces with a leading space and unfolds losslessly", () => {
+    const line: string = `DESCRIPTION:${"a".repeat(300)}`;
+    const folded: string = ICalendar.foldLine(line);
+    const pieces: Array<string> = folded.split(CRLF);
+
+    expect(pieces.length).toBeGreaterThan(1);
+    expect(octets(pieces[0]!)).toBe(75);
+
+    for (let i: number = 1; i < pieces.length; i++) {
+      expect(pieces[i]!.startsWith(" ")).toBe(true);
+      expect(octets(pieces[i]!)).toBeLessThanOrEqual(75);
+    }
+
+    // Every continuation but the last is packed to the limit.
+    for (let i: number = 1; i < pieces.length - 1; i++) {
+      expect(octets(pieces[i]!)).toBe(75);
+    }
+
+    expect(ICalendar.unfold(folded)).toBe(line);
+  });
+
+  test("never splits a 2-octet character", () => {
+    // "SUMMARY:" is 8 octets; 33 x "é" (66) fits, the 34th would make 76.
+    const line: string = `SUMMARY:${"é".repeat(120)}`;
+    const folded: string = ICalendar.foldLine(line);
+    const pieces: Array<string> = folded.split(CRLF);
+
+    expect(pieces[0]).toBe(`SUMMARY:${"é".repeat(33)}`);
+    expect(octets(pieces[0]!)).toBe(74);
+
+    for (const piece of pieces) {
+      expect(octets(piece)).toBeLessThanOrEqual(ICALENDAR_MAX_LINE_OCTETS);
+      expect(piece).not.toMatch(LONE_SURROGATE);
+      expect(Buffer.from(piece, "utf8").toString("utf8")).toBe(piece);
+    }
+
+    expect(ICalendar.unfold(folded)).toBe(line);
+  });
+
+  test("never splits a 3-octet or 4-octet character", () => {
+    for (const char of ["東", "😀"]) {
+      const line: string = `X:${char.repeat(90)}`;
+      const folded: string = ICalendar.foldLine(line);
+
+      for (const piece of folded.split(CRLF)) {
+        expect(octets(piece)).toBeLessThanOrEqual(ICALENDAR_MAX_LINE_OCTETS);
+        expect(piece).not.toMatch(LONE_SURROGATE);
+        expect(Buffer.from(piece, "utf8").toString("utf8")).toBe(piece);
+      }
+
+      expect(ICalendar.unfold(folded)).toBe(line);
+    }
+  });
+
+  test("a mixed-width line packs each physical line as full as the boundary allows", () => {
+    const line: string = `DESCRIPTION:${"ab😀é東".repeat(40)}`;
+    const folded: string = ICalendar.foldLine(line);
+    const pieces: Array<string> = folded.split(CRLF);
+
+    expect(pieces.length).toBeGreaterThan(2);
+
+    for (let i: number = 0; i < pieces.length; i++) {
+      const piece: string = pieces[i]!;
+      expect(octets(piece)).toBeLessThanOrEqual(75);
+      // Every piece but the last is packed to within one character of the limit.
+      if (i < pieces.length - 1) {
+        expect(octets(piece)).toBeGreaterThan(70);
+      }
+      expect(piece).not.toMatch(LONE_SURROGATE);
+      if (i > 0) {
+        expect(piece.startsWith(" ")).toBe(true);
+      }
+    }
+
+    expect(ICalendar.unfold(folded)).toBe(line);
+  });
+
+  test("a serialized document has no physical line over 75 octets and unfolds to the logical lines", () => {
+    const document: ICalendarDocument = {
+      calendar: {
+        ...baseCalendar(),
+        description: "Ærø ".repeat(60),
+      },
+      events: [
+        {
+          ...baseEvent(),
+          summary: "😀".repeat(50),
+          description: "東京".repeat(100),
+        },
+      ],
+    };
+
+    const body: string = ICalendar.serialize(document);
+
+    for (const line of physicalLines(body)) {
+      expect(octets(line)).toBeLessThanOrEqual(ICALENDAR_MAX_LINE_OCTETS);
+      expect(line).not.toMatch(LONE_SURROGATE);
+    }
+
+    const unfolded: string = ICalendar.unfold(body);
+    expect(unfolded).toContain(`SUMMARY:${"😀".repeat(50)}\r\n`);
+    expect(unfolded).toContain(`DESCRIPTION:${"東京".repeat(100)}\r\n`);
+  });
+});
+
+describe("ICalendar.getUtf8OctetLength", () => {
+  test("counts 1/2/3/4 octet characters", () => {
+    expect(ICalendar.getUtf8OctetLength("abc")).toBe(3);
+    expect(ICalendar.getUtf8OctetLength("é")).toBe(2);
+    expect(ICalendar.getUtf8OctetLength("東")).toBe(3);
+    expect(ICalendar.getUtf8OctetLength("😀")).toBe(4);
+    expect(ICalendar.getUtf8OctetLength("aé東😀")).toBe(
+      Buffer.byteLength("aé東😀", "utf8"),
+    );
+  });
+});
+
+describe("ICalendar.contentLine / textLine", () => {
+  test("upper-cases the name and parameter names", () => {
+    expect(ICalendar.contentLine("x-thing", "v", { value: "duration" })).toBe(
+      "X-THING;VALUE=duration:v",
+    );
+  });
+
+  test("quotes parameter values containing reserved characters and strips double quotes", () => {
+    expect(ICalendar.contentLine("P", "v", { cn: 'Doe, "John"' })).toBe(
+      'P;CN="Doe, John":v',
+    );
+    expect(ICalendar.contentLine("P", "v", { cn: "a:b" })).toBe('P;CN="a:b":v');
+  });
+
+  test("strips line breaks from any value", () => {
+    expect(ICalendar.contentLine("URL", "https://x\r\n.test")).toBe(
+      "URL:https://x.test",
+    );
+  });
+
+  test("textLine escapes the value", () => {
+    expect(ICalendar.textLine("SUMMARY", "a, b; c")).toBe(
+      "SUMMARY:a\\, b\\; c",
+    );
+  });
+});

package/Tests/Types/Database/DatabaseProperty.test.ts

@@ -0,0 +1,171 @@
+import DatabaseProperty from "../../../Types/Database/DatabaseProperty";
+import NotImplementedException from "../../../Types/Exception/NotImplementedException";
+import { JSONArray, JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+import { Equal, FindOperator, In, Not } from "typeorm";
+import { ValueTransformer } from "typeorm/decorator/options/ValueTransformer";
+
+/*
+ * DatabaseProperty is the base every value-object column type extends. Its
+ * TypeORM ValueTransformer carries three pieces of behavior that are easy to
+ * break and expensive to break:
+ *
+ *   - `to(undefined)` must stay `undefined` so an omitted column falls to its
+ *     SQL DEFAULT instead of being rewritten to an explicit NULL (a not-null
+ *     constraint violation / HTTP 500 on every create otherwise).
+ *   - a Raw query object must pass straight through untouched.
+ *   - a FindOperator (Equal/In/Not/And/...) must keep its structure while its
+ *     leaf value(s) are converted, so a privacy/scope clause is preserved.
+ *
+ * DatabasePropertyFindOperator.test.ts checks the concrete subclasses. This
+ * suite pins the base-class dispatch itself, using a tiny subclass whose
+ * conversion is observable (uppercasing).
+ */
+
+// A minimal concrete DatabaseProperty whose conversions are observable.
+class UpperCaseProperty extends DatabaseProperty {
+  public value: string;
+
+  public constructor(value: string) {
+    super();
+    this.value = value;
+  }
+
+  protected static override fromDatabase(
+    value: string | number | JSONObject | JSONArray,
+  ): DatabaseProperty | Array<DatabaseProperty> | null {
+    return new UpperCaseProperty(String(value));
+  }
+
+  protected static override toDatabase(
+    value: DatabaseProperty | Array<DatabaseProperty> | any,
+  ): string | number | JSONObject | JSONArray | null {
+    if (value instanceof UpperCaseProperty) {
+      return value.value.toUpperCase();
+    }
+
+    if (typeof value === "string") {
+      return value.toUpperCase();
+    }
+
+    return null;
+  }
+}
+
+describe("DatabaseProperty", () => {
+  describe("getDatabaseTransformer().to", () => {
+    it("passes undefined through unchanged so the SQL DEFAULT survives", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      // The whole point: undefined must NOT become null here.
+      expect(transformer.to(undefined)).toBeUndefined();
+    });
+
+    it("delegates a plain value to the subclass toDatabase", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      expect(transformer.to(new UpperCaseProperty("hello"))).toBe("HELLO");
+    });
+
+    it("passes a raw query object straight through without conversion", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const raw: JSONObject = { _type: "raw", value: "keep me as-is" };
+      const result: unknown = transformer.to(raw);
+
+      // Same object, untouched - toDatabase (which uppercases) never ran.
+      expect(result).toBe(raw);
+      expect((result as JSONObject)["value"]).toBe("keep me as-is");
+    });
+
+    it("preserves an Equal FindOperator and converts only its leaf", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const operator: FindOperator<string> = Equal("abc");
+      const result: unknown = transformer.to(operator);
+
+      // Structure kept (same instance), leaf converted.
+      expect(result).toBe(operator);
+      expect((result as FindOperator<string>).value).toBe("ABC");
+    });
+
+    it("preserves a Not FindOperator and converts its leaf", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const operator: FindOperator<string> = Not("nope");
+      const result: unknown = transformer.to(operator);
+
+      expect(result).toBe(operator);
+      expect((result as FindOperator<string>).value).toBe("NOPE");
+    });
+
+    it("converts every leaf of a multi-value In FindOperator", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const operator: FindOperator<Array<string>> = In(["a", "b", "c"]);
+      const result: unknown = transformer.to(operator);
+
+      expect(result).toBe(operator);
+      expect((result as FindOperator<Array<string>>).value).toEqual([
+        "A",
+        "B",
+        "C",
+      ]);
+    });
+
+    it("is a fixpoint: transforming its own output again is a no-op", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const operator: FindOperator<string> = Equal("abc");
+      transformer.to(operator);
+      // Second pass (BaseAPI.getList shares the query between findBy/countBy).
+      transformer.to(operator);
+
+      expect(operator.value).toBe("ABC");
+    });
+  });
+
+  describe("getDatabaseTransformer().from", () => {
+    it("delegates to the subclass fromDatabase", () => {
+      const transformer: ValueTransformer =
+        UpperCaseProperty.getDatabaseTransformer();
+
+      const result: unknown = transformer.from("stored");
+
+      expect(result).toBeInstanceOf(UpperCaseProperty);
+      expect((result as UpperCaseProperty).value).toBe("stored");
+    });
+  });
+
+  describe("base class defaults", () => {
+    it("getSchema throws NotImplementedException on the base class", () => {
+      expect(() => {
+        return DatabaseProperty.getSchema();
+      }).toThrow(NotImplementedException);
+    });
+
+    it("still short-circuits undefined even on the un-implemented base", () => {
+      const transformer: ValueTransformer =
+        DatabaseProperty.getDatabaseTransformer();
+
+      // Reaches the undefined guard before the un-implemented toDatabase.
+      expect(transformer.to(undefined)).toBeUndefined();
+    });
+
+    it("throws NotImplementedException when the base must actually convert", () => {
+      const transformer: ValueTransformer =
+        DatabaseProperty.getDatabaseTransformer();
+
+      expect(() => {
+        return transformer.to("a real value");
+      }).toThrow(NotImplementedException);
+    });
+  });
+});