@oneuptime/common 12.0.12 → 12.0.14

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

@@ -0,0 +1,286 @@
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import Project from "../../../Models/DatabaseModels/Project";
+import {
+  TableColumnMetadata,
+  getTableColumn,
+  getTableColumns,
+} from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import Dictionary from "../../../Types/Dictionary";
+import "reflect-metadata";
+
+type ModelCtor = new () => DatabaseBaseModel;
+
+const MODELS: Array<[string, ModelCtor]> = [
+  ["Monitor", Monitor],
+  ["Incident", Incident],
+  ["Project", Project],
+];
+
+/*
+ * Locate the module-private metadata symbol (e.g. Symbol(TableColumn)) by
+ * scanning the metadata keys of every instance property, so the tests can
+ * rebuild the dictionary from scratch exactly the way the pre-cache
+ * implementation did — without importing any private state.
+ */
+function findMetadataSymbol(
+  model: DatabaseBaseModel,
+  symbolName: string,
+): symbol | null {
+  for (const key of Object.keys(model)) {
+    const metadataKeys: Array<unknown> = Reflect.getMetadataKeys(
+      model,
+      key,
+    ) as Array<unknown>;
+    for (const metadataKey of metadataKeys) {
+      if (
+        typeof metadataKey === "symbol" &&
+        metadataKey.toString() === `Symbol(${symbolName})`
+      ) {
+        return metadataKey;
+      }
+    }
+  }
+  return null;
+}
+
+// The exact algorithm getTableColumns() used before caching was introduced.
+function rebuildFromReflect<T>(
+  model: DatabaseBaseModel,
+  symbolName: string,
+): Dictionary<T> {
+  const metadataSymbol: symbol | null = findMetadataSymbol(model, symbolName);
+  const dictionary: Dictionary<T> = {};
+
+  if (!metadataSymbol) {
+    return dictionary;
+  }
+
+  for (const key of Object.keys(model)) {
+    const metadata: T | undefined = Reflect.getMetadata(
+      metadataSymbol,
+      model,
+      key,
+    ) as T | undefined;
+    if (metadata) {
+      dictionary[key] = metadata;
+    }
+  }
+
+  return dictionary;
+}
+
+function rebuildTableColumns(
+  model: DatabaseBaseModel,
+): Dictionary<TableColumnMetadata> {
+  return rebuildFromReflect<TableColumnMetadata>(model, "TableColumn");
+}
+
+describe("getTableColumns caching", () => {
+  for (const [name, ModelClass] of MODELS) {
+    test(`matches a from-scratch Reflect rebuild for ${name} — keys, order, and value identity`, () => {
+      const model: DatabaseBaseModel = new ModelClass();
+      const expected: Dictionary<TableColumnMetadata> =
+        rebuildTableColumns(model);
+      const actual: Dictionary<TableColumnMetadata> = getTableColumns(model);
+
+      // Sanity: real models have plenty of decorated columns.
+      expect(Object.keys(expected).length).toBeGreaterThan(5);
+
+      // Same keys in the same insertion order.
+      expect(Object.keys(actual)).toEqual(Object.keys(expected));
+
+      // Values are the exact same Reflect metadata singletons as before.
+      for (const key of Object.keys(expected)) {
+        expect(actual[key]).toBe(expected[key]);
+      }
+    });
+  }
+
+  test("second call for the same class performs zero Reflect metadata reads", () => {
+    const monitor: Monitor = new Monitor();
+    const expected: Dictionary<TableColumnMetadata> =
+      rebuildTableColumns(monitor);
+
+    getTableColumns(monitor); // warm the cache
+
+    const spy: jest.SpyInstance = jest.spyOn(Reflect, "getMetadata");
+    try {
+      const result: Dictionary<TableColumnMetadata> = getTableColumns(monitor);
+      expect(spy).not.toHaveBeenCalled();
+      expect(Object.keys(result)).toEqual(Object.keys(expected));
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("cache is shared across different instances of the same class", () => {
+    getTableColumns(new Monitor()); // warm the cache with one instance
+
+    const spy: jest.SpyInstance = jest.spyOn(Reflect, "getMetadata");
+    try {
+      const result: Dictionary<TableColumnMetadata> = getTableColumns(
+        new Monitor(),
+      );
+      expect(spy).not.toHaveBeenCalled();
+      expect(result["name"]).toBeDefined();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("different classes get distinct dictionaries", () => {
+    const monitorColumns: Dictionary<TableColumnMetadata> = getTableColumns(
+      new Monitor(),
+    );
+    const incidentColumns: Dictionary<TableColumnMetadata> = getTableColumns(
+      new Incident(),
+    );
+    const projectColumns: Dictionary<TableColumnMetadata> = getTableColumns(
+      new Project(),
+    );
+
+    expect(monitorColumns).not.toBe(incidentColumns);
+    expect(monitorColumns).not.toBe(projectColumns);
+    expect(incidentColumns).not.toBe(projectColumns);
+
+    expect(Object.keys(monitorColumns)).not.toEqual(
+      Object.keys(incidentColumns),
+    );
+    expect(monitorColumns["monitorType"]).toBeDefined();
+    expect(incidentColumns["monitorType"]).toBeUndefined();
+    expect(projectColumns["monitorType"]).toBeUndefined();
+  });
+
+  test("mutations by one caller never leak into later calls (API reference deletes entries)", () => {
+    const expected: Dictionary<TableColumnMetadata> = rebuildTableColumns(
+      new Monitor(),
+    );
+
+    const first: Dictionary<TableColumnMetadata> = getTableColumns(
+      new Monitor(),
+    );
+
+    // The API reference docs page strips columns exactly like this.
+    delete first["deletedAt"];
+    delete first["version"];
+    delete first["name"];
+    first["monitorType"] = { type: TableColumnType.Phone };
+
+    const second: Dictionary<TableColumnMetadata> = getTableColumns(
+      new Monitor(),
+    );
+
+    expect(second).not.toBe(first);
+    expect(Object.keys(second)).toEqual(Object.keys(expected));
+    expect(second["deletedAt"]).toBe(expected["deletedAt"]);
+    expect(second["version"]).toBe(expected["version"]);
+    expect(second["name"]).toBe(expected["name"]);
+    expect(second["monitorType"]).toBe(expected["monitorType"]);
+    expect(second["monitorType"]!.type).not.toBe(TableColumnType.Phone);
+  });
+
+  test("Columns wrapper on the model still lists every decorated column", () => {
+    for (const [, ModelClass] of MODELS) {
+      const model: DatabaseBaseModel = new ModelClass();
+      const expected: Dictionary<TableColumnMetadata> =
+        rebuildTableColumns(model);
+      expect(model.getTableColumns().columns).toEqual(Object.keys(expected));
+    }
+  });
+
+  test("filter helpers derive from identical metadata after caching", () => {
+    for (const [, ModelClass] of MODELS) {
+      const model: DatabaseBaseModel = new ModelClass();
+      const expected: Dictionary<TableColumnMetadata> =
+        rebuildTableColumns(model);
+
+      const expectedFor: (
+        predicate: (metadata: TableColumnMetadata) => boolean,
+      ) => Array<string> = (
+        predicate: (metadata: TableColumnMetadata) => boolean,
+      ): Array<string> => {
+        return Object.keys(expected).filter((key: string) => {
+          return predicate(expected[key] as TableColumnMetadata);
+        });
+      };
+
+      expect(model.getRequiredColumns().columns).toEqual(
+        expectedFor((metadata: TableColumnMetadata) => {
+          return Boolean(metadata.required);
+        }),
+      );
+      expect(model.getUniqueColumns().columns).toEqual(
+        expectedFor((metadata: TableColumnMetadata) => {
+          return Boolean(metadata.unique);
+        }),
+      );
+      expect(model.getHashedColumns().columns).toEqual(
+        expectedFor((metadata: TableColumnMetadata) => {
+          return Boolean(metadata.hashed);
+        }),
+      );
+      expect(model.getEncryptedColumns().columns).toEqual(
+        expectedFor((metadata: TableColumnMetadata) => {
+          return Boolean(metadata.encrypted);
+        }),
+      );
+    }
+  });
+});
+
+describe("getTableColumnMetadata", () => {
+  for (const [name, ModelClass] of MODELS) {
+    test(`returns the exact rebuild value for every instance key of ${name}`, () => {
+      const model: DatabaseBaseModel = new ModelClass();
+      const expected: Dictionary<TableColumnMetadata> =
+        rebuildTableColumns(model);
+
+      for (const key of Object.keys(model)) {
+        const expectedValue: TableColumnMetadata | undefined = expected[key];
+        const actualValue: TableColumnMetadata =
+          model.getTableColumnMetadata(key);
+
+        if (expectedValue) {
+          expect(actualValue).toBe(expectedValue);
+        } else {
+          // Undecorated instance keys (e.g. isPermissionIf) stay undefined.
+          expect(actualValue).toBeUndefined();
+        }
+      }
+    });
+  }
+
+  test("returns undefined for unknown keys", () => {
+    const monitor: Monitor = new Monitor();
+    expect(monitor.getTableColumnMetadata("doesNotExist")).toBeUndefined();
+    expect(monitor.getTableColumnMetadata("")).toBeUndefined();
+    expect(monitor.getTableColumnMetadata("constructor")).toBeUndefined();
+    expect(monitor.getTableColumnMetadata("isPermissionIf")).toBeUndefined();
+  });
+
+  test("agrees with the standalone single-column reader", () => {
+    const monitor: Monitor = new Monitor();
+    for (const key of Object.keys(monitor)) {
+      expect(monitor.getTableColumnMetadata(key)).toBe(
+        getTableColumn(monitor, key),
+      );
+    }
+  });
+
+  test("reads a single metadata entry instead of rebuilding the whole dictionary", () => {
+    const monitor: Monitor = new Monitor();
+
+    const spy: jest.SpyInstance = jest.spyOn(Reflect, "getMetadata");
+    try {
+      const metadata: TableColumnMetadata =
+        monitor.getTableColumnMetadata("name");
+      expect(metadata).toBeDefined();
+      expect(spy).toHaveBeenCalledTimes(1);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/Tests/Types/Incident/IncidentSlaStatus.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "@jest/globals";
+import IncidentSlaStatus from "../../../Types/Incident/IncidentSlaStatus";
+
+/*
+ * IncidentSlaStatus is a plain string enum. These tests lock in the exact
+ * string value of every member, the structural invariants of the enum object
+ * (member count, key set, value uniqueness, absence of a reverse mapping) and
+ * the runtime semantics that consumers rely on (equality, switch dispatch and
+ * membership checks). Everything here is deterministic and pure: no network,
+ * database, wall-clock or randomness is involved.
+ */
+
+describe("enum IncidentSlaStatus", () => {
+  describe("member values", () => {
+    test("OnTrack maps to the human-readable 'On Track'", () => {
+      expect(IncidentSlaStatus.OnTrack).toBe("On Track");
+    });
+
+    test("AtRisk maps to the human-readable 'At Risk'", () => {
+      expect(IncidentSlaStatus.AtRisk).toBe("At Risk");
+    });
+
+    test("ResponseBreached maps to 'Response Breached'", () => {
+      expect(IncidentSlaStatus.ResponseBreached).toBe("Response Breached");
+    });
+
+    test("ResolutionBreached maps to 'Resolution Breached'", () => {
+      expect(IncidentSlaStatus.ResolutionBreached).toBe("Resolution Breached");
+    });
+
+    test("Met maps to 'Met'", () => {
+      expect(IncidentSlaStatus.Met).toBe("Met");
+    });
+  });
+
+  describe("structural invariants", () => {
+    test("exposes exactly five members", () => {
+      /*
+       * A string enum produces no reverse numeric mapping, so the key count is
+       * exactly the number of declared members.
+       */
+      const keys: Array<string> = Object.keys(IncidentSlaStatus);
+      expect(keys).toHaveLength(5);
+    });
+
+    test("declares the full, ordered key set", () => {
+      const keys: Array<string> = Object.keys(IncidentSlaStatus);
+      expect(keys).toEqual([
+        "OnTrack",
+        "AtRisk",
+        "ResponseBreached",
+        "ResolutionBreached",
+        "Met",
+      ]);
+    });
+
+    test("declares the full, ordered value set", () => {
+      const values: Array<string> = Object.values(IncidentSlaStatus);
+      expect(values).toEqual([
+        "On Track",
+        "At Risk",
+        "Response Breached",
+        "Resolution Breached",
+        "Met",
+      ]);
+    });
+
+    test("every member value is unique", () => {
+      const values: Array<string> = Object.values(IncidentSlaStatus);
+      const uniqueValues: Set<string> = new Set(values);
+      expect(uniqueValues.size).toBe(values.length);
+    });
+
+    test("every member key is unique", () => {
+      const keys: Array<string> = Object.keys(IncidentSlaStatus);
+      const uniqueKeys: Set<string> = new Set(keys);
+      expect(uniqueKeys.size).toBe(keys.length);
+    });
+
+    test("has no reverse mapping from value back to key", () => {
+      /*
+       * Numeric enums create a reverse mapping (obj[0] === "Key"), which would
+       * pollute the key set. A string enum must not; guard against a member
+       * accidentally becoming numeric. The values below all contain a space, so
+       * they can never coincide with a member key and unambiguously prove that
+       * no value-to-key entry exists.
+       */
+      const record: Record<string, string> =
+        IncidentSlaStatus as unknown as Record<string, string>;
+      expect(record["On Track"]).toBeUndefined();
+      expect(record["At Risk"]).toBeUndefined();
+      expect(record["Response Breached"]).toBeUndefined();
+      expect(record["Resolution Breached"]).toBeUndefined();
+    });
+
+    test("every value is a non-empty string", () => {
+      const values: Array<string> = Object.values(IncidentSlaStatus);
+      for (const value of values) {
+        expect(typeof value).toBe("string");
+        expect(value.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("runtime semantics", () => {
+    test("distinct members are not equal to one another", () => {
+      const members: Array<IncidentSlaStatus> = [
+        IncidentSlaStatus.OnTrack,
+        IncidentSlaStatus.AtRisk,
+        IncidentSlaStatus.ResponseBreached,
+        IncidentSlaStatus.ResolutionBreached,
+        IncidentSlaStatus.Met,
+      ];
+
+      for (let i: number = 0; i < members.length; i++) {
+        for (let j: number = 0; j < members.length; j++) {
+          if (i === j) {
+            expect(members[i]).toBe(members[j]);
+          } else {
+            expect(members[i]).not.toBe(members[j]);
+          }
+        }
+      }
+    });
+
+    test("a member can be located by its string value", () => {
+      const values: Array<string> = Object.values(IncidentSlaStatus);
+      expect(values.includes(IncidentSlaStatus.ResponseBreached)).toBe(true);
+      expect(values.includes("Not A Status")).toBe(false);
+    });
+
+    test("drives switch dispatch by member identity", () => {
+      /*
+       * classify is a tiny local pure helper. It exercises every enum branch
+       * plus the exhaustive default so a switch over the enum is verified to
+       * reach each case deterministically.
+       */
+      const classify: (status: IncidentSlaStatus) => string = (
+        status: IncidentSlaStatus,
+      ): string => {
+        switch (status) {
+          case IncidentSlaStatus.OnTrack:
+            return "healthy";
+          case IncidentSlaStatus.AtRisk:
+            return "warning";
+          case IncidentSlaStatus.ResponseBreached:
+          case IncidentSlaStatus.ResolutionBreached:
+            return "breached";
+          case IncidentSlaStatus.Met:
+            return "closed";
+          default:
+            return "unknown";
+        }
+      };
+
+      expect(classify(IncidentSlaStatus.OnTrack)).toBe("healthy");
+      expect(classify(IncidentSlaStatus.AtRisk)).toBe("warning");
+      expect(classify(IncidentSlaStatus.ResponseBreached)).toBe("breached");
+      expect(classify(IncidentSlaStatus.ResolutionBreached)).toBe("breached");
+      expect(classify(IncidentSlaStatus.Met)).toBe("closed");
+    });
+
+    test("an out-of-enum value falls through switch to the default branch", () => {
+      const classify: (status: IncidentSlaStatus) => string = (
+        status: IncidentSlaStatus,
+      ): string => {
+        switch (status) {
+          case IncidentSlaStatus.OnTrack:
+            return "healthy";
+          default:
+            return "unknown";
+        }
+      };
+
+      /*
+       * A raw string that is not one of the enum values must not match any
+       * case. Cast through unknown to feed the negative/edge input safely.
+       */
+      const strayValue: IncidentSlaStatus =
+        "In Progress" as unknown as IncidentSlaStatus;
+      expect(classify(strayValue)).toBe("unknown");
+    });
+
+    test("serializes to its string value in JSON, not to an index", () => {
+      const payload: { status: IncidentSlaStatus } = {
+        status: IncidentSlaStatus.ResolutionBreached,
+      };
+      expect(JSON.stringify(payload)).toBe('{"status":"Resolution Breached"}');
+    });
+  });
+});