@oneuptime/common 12.0.12 → 12.0.13

package/Tests/Server/Utils/Workspace/MicrosoftTeamsTeamInstalls.test.ts

@@ -584,9 +584,37 @@ describe("MicrosoftTeamsUtil.removeTeamFromBotActivity", () => {
     });
 
     expect(removeSpy).toHaveBeenCalledTimes(1);
+    /*
+     * Uninstall passes both ids: the bot is already out of the team so the
+     * Graph id cannot be looked up, and records written before it was captured
+     * are only findable by the thread id. TEAM_ID here is a thread id, matching
+     * what channelData.team.id carries.
+     */
     expect(removeSpy).toHaveBeenCalledWith({
       tenantId: TENANT_ID,
-      teamId: TEAM_ID,
+      teamsThreadId: TEAM_ID,
+      graphTeamId: undefined,
+    });
+  });
+
+  test("an uninstall activity that still carries aadGroupId passes it through", async () => {
+    const removeSpy: jest.SpyInstance = jest
+      .spyOn(MicrosoftTeamsUtil, "removeTeamFromProjectAuthTokens")
+      .mockResolvedValue(undefined as never);
+
+    await MicrosoftTeamsUtil.removeTeamFromBotActivity({
+      activity: teamActivity({
+        channelData: {
+          team: { id: TEAM_ID, aadGroupId: "graph-team-1" },
+          tenant: { id: TENANT_ID },
+        },
+      }),
+    });
+
+    expect(removeSpy).toHaveBeenCalledWith({
+      tenantId: TENANT_ID,
+      teamsThreadId: TEAM_ID,
+      graphTeamId: "graph-team-1",
     });
   });
 
@@ -884,7 +912,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: TEAM_ID,
+      teamsThreadId: TEAM_ID,
     });
 
     expect(findBySpy).toHaveBeenCalledWith(
@@ -925,7 +953,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: teamToRemove.id,
+      teamsThreadId: teamToRemove.id,
     });
 
     expect(updateSpy).toHaveBeenCalledTimes(1);
@@ -950,7 +978,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: team.id,
+      teamsThreadId: team.id,
     });
 
     const savedMiscData: MicrosoftTeamsMiscData = getUpdateArgs(updateSpy, 0)
@@ -976,7 +1004,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: TEAM_ID,
+      teamsThreadId: TEAM_ID,
     });
 
     expect(updateSpy).not.toHaveBeenCalled();
@@ -991,7 +1019,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: TEAM_ID,
+      teamsThreadId: TEAM_ID,
     });
 
     expect(updateSpy).not.toHaveBeenCalled();
@@ -1014,7 +1042,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: team.id,
+      teamsThreadId: team.id,
     });
 
     expect(updateSpy).toHaveBeenCalledTimes(3);
@@ -1068,7 +1096,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: team.id,
+      teamsThreadId: team.id,
     });
 
     expect(updateSpy).toHaveBeenCalledTimes(1);
@@ -1104,7 +1132,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: "19:team-aaa@thread.tacv2",
+      teamsThreadId: "19:team-aaa@thread.tacv2",
     });
 
     expect(updateSpy).not.toHaveBeenCalled();
@@ -1120,7 +1148,7 @@ describe("MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens", () => {
 
     await MicrosoftTeamsUtil.removeTeamFromProjectAuthTokens({
       tenantId: "tenant-abc",
-      teamId: team.id,
+      teamsThreadId: team.id,
     });
 
     expect(originalMiscData.installedTeams).toEqual({ [team.id]: team });
@@ -1495,9 +1523,15 @@ describe("MicrosoftTeamsUtil.handleBotMessageActivity - team install backfill wi
     });
 
     expect(spies.captureTeamSpy).toHaveBeenCalledTimes(1);
+    /*
+     * onlyIfMissingOrStale, because this runs on every inbound channel message:
+     * once the team is recorded it must cost one read, not a write plus a
+     * possible Bot Framework call to resolve the group id.
+     */
     expect(spies.captureTeamSpy).toHaveBeenCalledWith({
       activity: activity,
       turnContext: turnContext,
+      onlyIfMissingOrStale: true,
     });
     expect(spies.captureChatSpy).not.toHaveBeenCalled();
   });

package/Tests/Types/API/HostnameFromAuthority.test.ts

@@ -0,0 +1,164 @@
+import Hostname from "../../../Types/API/Hostname";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Hostname.fromAuthority splits a URL authority into a bare host and a real
+ * Port. It exists because URL.fromString hands the WHOLE authority to the
+ * Hostname constructor, so `URL.fromString("https://example.com:8443/")`
+ * yields a hostname of "example.com:8443" and no port at all.
+ *
+ * Anything that reads the structured accessors rather than toString() then
+ * dials a host that does not exist. The SSL Certificate Monitor is one such
+ * consumer, which is why a monitor on a non-443 port could never connect —
+ * see https://github.com/OneUptime/oneuptime/issues/3225.
+ *
+ * fromString() is NOT a substitute: it splits on the FIRST colon, which
+ * mangles every IPv6 literal.
+ */
+describe("Hostname.fromAuthority", () => {
+  describe("host and port", () => {
+    test("splits a trailing port off the host", () => {
+      const hostname: Hostname = Hostname.fromAuthority("example.com:8443");
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port?.toNumber()).toBe(8443);
+    });
+
+    test("leaves a bare host without a port", () => {
+      const hostname: Hostname = Hostname.fromAuthority("example.com");
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port).toBeUndefined();
+    });
+
+    test("handles localhost with a port", () => {
+      const hostname: Hostname = Hostname.fromAuthority("localhost:5000");
+
+      expect(hostname.hostname).toBe("localhost");
+      expect(hostname.port?.toNumber()).toBe(5000);
+    });
+
+    test("handles an IPv4 literal with a port", () => {
+      const hostname: Hostname = Hostname.fromAuthority("127.0.0.1:8443");
+
+      expect(hostname.hostname).toBe("127.0.0.1");
+      expect(hostname.port?.toNumber()).toBe(8443);
+    });
+
+    test("round-trips back to the original authority", () => {
+      expect(Hostname.fromAuthority("example.com:8443").toString()).toBe(
+        "example.com:8443",
+      );
+      expect(Hostname.fromAuthority("example.com").toString()).toBe(
+        "example.com",
+      );
+    });
+  });
+
+  describe("IPv6 literals", () => {
+    test("keeps a bracketed IPv6 address intact and takes its port", () => {
+      const hostname: Hostname = Hostname.fromAuthority("[::1]:8443");
+
+      expect(hostname.hostname).toBe("[::1]");
+      expect(hostname.port?.toNumber()).toBe(8443);
+    });
+
+    test("keeps a bracketed IPv6 address with no port intact", () => {
+      const hostname: Hostname = Hostname.fromAuthority("[::1]");
+
+      expect(hostname.hostname).toBe("[::1]");
+      expect(hostname.port).toBeUndefined();
+    });
+
+    test("does not split an unbracketed IPv6 literal", () => {
+      /*
+       * Two or more colons cannot be a host:port, so every colon belongs to
+       * the address. fromString would have returned a host of "2001".
+       */
+      const hostname: Hostname = Hostname.fromAuthority("2001:db8::1");
+
+      expect(hostname.hostname).toBe("2001:db8::1");
+      expect(hostname.port).toBeUndefined();
+    });
+
+    test("a full bracketed IPv6 address survives with its port", () => {
+      const hostname: Hostname = Hostname.fromAuthority(
+        "[2001:db8::8a2e:370:7334]:9000",
+      );
+
+      expect(hostname.hostname).toBe("[2001:db8::8a2e:370:7334]");
+      expect(hostname.port?.toNumber()).toBe(9000);
+    });
+  });
+
+  describe("userinfo", () => {
+    test("drops userinfo and keeps the host", () => {
+      const hostname: Hostname = Hostname.fromAuthority(
+        "user:token@hooks.example.com",
+      );
+
+      expect(hostname.hostname).toBe("hooks.example.com");
+      expect(hostname.port).toBeUndefined();
+    });
+
+    test("drops userinfo and keeps host and port", () => {
+      const hostname: Hostname = Hostname.fromAuthority(
+        "user:token@example.com:8443",
+      );
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port?.toNumber()).toBe(8443);
+    });
+
+    test("splits on the LAST @, since userinfo may contain one", () => {
+      const hostname: Hostname = Hostname.fromAuthority(
+        "user@name:token@example.com:8443",
+      );
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port?.toNumber()).toBe(8443);
+    });
+  });
+
+  describe("malformed input", () => {
+    test("an empty authority yields an empty hostname rather than throwing", () => {
+      expect(Hostname.fromAuthority("").hostname).toBe("");
+    });
+
+    test("a trailing colon with no digits is not treated as a port", () => {
+      const hostname: Hostname = Hostname.fromAuthority("example.com:");
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port).toBeUndefined();
+    });
+
+    test("surrounding whitespace is trimmed", () => {
+      const hostname: Hostname = Hostname.fromAuthority("  example.com:443  ");
+
+      expect(hostname.hostname).toBe("example.com");
+      expect(hostname.port?.toNumber()).toBe(443);
+    });
+  });
+
+  describe("contrast with fromString", () => {
+    test("fromString rejects an IPv6 literal that fromAuthority handles", () => {
+      /*
+       * Pinned deliberately: it documents WHY fromAuthority exists, and
+       * guards against someone 'simplifying' one into the other.
+       *
+       * fromString splits on the FIRST colon, so "[::1]:8443" becomes a
+       * host of "[" - which the Hostname setter rejects outright.
+       */
+      expect(Hostname.fromAuthority("[::1]:8443").hostname).toBe("[::1]");
+      expect(() => {
+        return Hostname.fromString("[::1]:8443");
+      }).toThrow();
+    });
+
+    test("both agree on the simple host:port case", () => {
+      expect(Hostname.fromAuthority("example.com:8443").hostname).toBe(
+        Hostname.fromString("example.com:8443").hostname,
+      );
+    });
+  });
+});

package/Tests/Types/Database/AccessControl/ColumnAccessControlCache.test.ts

@@ -0,0 +1,344 @@
+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 StatusPage from "../../../../Models/DatabaseModels/StatusPage";
+import { ColumnAccessControl } from "../../../../Types/BaseDatabase/AccessControl";
+import ColumnBillingAccessControl from "../../../../Types/BaseDatabase/ColumnBillingAccessControl";
+import { getColumnAccessControlForAllColumns } from "../../../../Types/Database/AccessControl/ColumnAccessControl";
+import { getColumnBillingAccessControlForAllColumns } from "../../../../Types/Database/AccessControl/ColumnBillingAccessControl";
+import Dictionary from "../../../../Types/Dictionary";
+import "reflect-metadata";
+
+type ModelCtor = new () => DatabaseBaseModel;
+
+const MODELS: Array<[string, ModelCtor]> = [
+  ["Monitor", Monitor],
+  ["Incident", Incident],
+  ["Project", Project],
+];
+
+// Monitor and Incident have no billing-decorated columns; StatusPage does.
+const BILLING_MODELS: Array<[string, ModelCtor]> = [["StatusPage", StatusPage]];
+
+const DEFAULT_COLUMNS: Array<string> = [
+  "_id",
+  "createdAt",
+  "deletedAt",
+  "updatedAt",
+];
+
+/*
+ * Locate the module-private metadata symbol (e.g. Symbol(ColumnAccessControl))
+ * 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 both helpers 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 rebuildAccessControl(
+  model: DatabaseBaseModel,
+): Dictionary<ColumnAccessControl> {
+  return rebuildFromReflect<ColumnAccessControl>(model, "ColumnAccessControl");
+}
+
+function rebuildBillingAccessControl(
+  model: DatabaseBaseModel,
+): Dictionary<ColumnBillingAccessControl> {
+  return rebuildFromReflect<ColumnBillingAccessControl>(
+    model,
+    "ColumnBillingAccessControl",
+  );
+}
+
+describe("getColumnAccessControlForAllColumns helper 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<ColumnAccessControl> =
+        rebuildAccessControl(model);
+      const actual: Dictionary<ColumnAccessControl> =
+        getColumnAccessControlForAllColumns(model);
+
+      // Sanity: real models have plenty of decorated columns.
+      expect(Object.keys(expected).length).toBeGreaterThan(5);
+
+      expect(Object.keys(actual)).toEqual(Object.keys(expected));
+      for (const key of Object.keys(expected)) {
+        expect(actual[key]).toBe(expected[key]);
+      }
+    });
+  }
+
+  test("repeated calls return the same dictionary object", () => {
+    const monitor: Monitor = new Monitor();
+    const first: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(monitor);
+    const second: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(monitor);
+
+    expect(second).toBe(first);
+  });
+
+  test("different instances of the same class share the cached dictionary", () => {
+    const first: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Monitor());
+    const second: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Monitor());
+
+    expect(second).toBe(first);
+  });
+
+  test("second call performs zero Reflect metadata reads", () => {
+    const incident: Incident = new Incident();
+    getColumnAccessControlForAllColumns(incident); // warm the cache
+
+    const spy: jest.SpyInstance = jest.spyOn(Reflect, "getMetadata");
+    try {
+      getColumnAccessControlForAllColumns(incident);
+      expect(spy).not.toHaveBeenCalled();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("different classes get distinct dictionaries", () => {
+    const monitorAccessControl: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Monitor());
+    const incidentAccessControl: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Incident());
+    const projectAccessControl: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Project());
+
+    expect(monitorAccessControl).not.toBe(incidentAccessControl);
+    expect(monitorAccessControl).not.toBe(projectAccessControl);
+    expect(incidentAccessControl).not.toBe(projectAccessControl);
+
+    expect(monitorAccessControl["monitorType"]).toBeDefined();
+    expect(incidentAccessControl["monitorType"]).toBeUndefined();
+  });
+});
+
+describe("DatabaseBaseModel.getColumnAccessControlForAllColumns override", () => {
+  test("adds default columns with record-level permissions, exactly as before", () => {
+    const monitor: Monitor = new Monitor();
+    const raw: Dictionary<ColumnAccessControl> = rebuildAccessControl(monitor);
+    const merged: Dictionary<ColumnAccessControl> =
+      monitor.getColumnAccessControlForAllColumns();
+
+    for (const key of DEFAULT_COLUMNS) {
+      expect(merged[key]).toEqual({
+        read: monitor.readRecordPermissions,
+        create: monitor.createRecordPermissions,
+        update: monitor.updateRecordPermissions,
+      });
+    }
+
+    // Decorated columns flow through as the exact same Reflect singletons.
+    for (const key of Object.keys(raw)) {
+      if (!DEFAULT_COLUMNS.includes(key)) {
+        expect(merged[key]).toBe(raw[key]);
+      }
+    }
+
+    expect(Object.keys(merged).sort()).toEqual(
+      [...Object.keys(raw), ...DEFAULT_COLUMNS].sort(),
+    );
+  });
+
+  test("never pollutes the raw helper dictionary with default columns", () => {
+    const monitor: Monitor = new Monitor();
+
+    const rawKeysBefore: Array<string> = Object.keys(
+      getColumnAccessControlForAllColumns(monitor),
+    );
+    for (const key of DEFAULT_COLUMNS) {
+      expect(rawKeysBefore).not.toContain(key);
+    }
+
+    monitor.getColumnAccessControlForAllColumns();
+    monitor.getColumnAccessControlForAllColumns();
+
+    /*
+     * AuditLogService.getRedactedFields consumes the raw helper result and
+     * must never see the record-level defaults the model override adds.
+     */
+    const rawAfter: Dictionary<ColumnAccessControl> =
+      getColumnAccessControlForAllColumns(new Monitor());
+    expect(Object.keys(rawAfter)).toEqual(rawKeysBefore);
+    for (const key of DEFAULT_COLUMNS) {
+      expect(rawAfter[key]).toBeUndefined();
+    }
+  });
+
+  test("mutating one override result does not affect the next call", () => {
+    const monitor: Monitor = new Monitor();
+
+    const first: Dictionary<ColumnAccessControl> =
+      monitor.getColumnAccessControlForAllColumns();
+    const originalName: ColumnAccessControl = first[
+      "name"
+    ] as ColumnAccessControl;
+    expect(originalName).toBeDefined();
+
+    delete first["name"];
+    first["_id"] = { read: [], create: [], update: [] };
+    first["injected"] = { read: [], create: [], update: [] };
+
+    const second: Dictionary<ColumnAccessControl> =
+      monitor.getColumnAccessControlForAllColumns();
+
+    expect(second).not.toBe(first);
+    expect(second["name"]).toBe(originalName);
+    expect(second["injected"]).toBeUndefined();
+    expect(second["_id"]).toEqual({
+      read: monitor.readRecordPermissions,
+      create: monitor.createRecordPermissions,
+      update: monitor.updateRecordPermissions,
+    });
+  });
+
+  test("getColumnAccessControlFor still resolves decorated, default, and unknown columns", () => {
+    const monitor: Monitor = new Monitor();
+    const raw: Dictionary<ColumnAccessControl> = rebuildAccessControl(monitor);
+
+    expect(monitor.getColumnAccessControlFor("name")).toBe(raw["name"]);
+    expect(monitor.getColumnAccessControlFor("_id")).toEqual({
+      read: monitor.readRecordPermissions,
+      create: monitor.createRecordPermissions,
+      update: monitor.updateRecordPermissions,
+    });
+    expect(monitor.getColumnAccessControlFor("doesNotExist")).toBeNull();
+  });
+});
+
+describe("getColumnBillingAccessControlForAllColumns helper caching", () => {
+  for (const [name, ModelClass] of [...MODELS, ...BILLING_MODELS]) {
+    test(`matches a from-scratch Reflect rebuild for ${name} — keys, order, and value identity`, () => {
+      const model: DatabaseBaseModel = new ModelClass();
+      const expected: Dictionary<ColumnBillingAccessControl> =
+        rebuildBillingAccessControl(model);
+      const actual: Dictionary<ColumnBillingAccessControl> =
+        getColumnBillingAccessControlForAllColumns(model);
+
+      expect(Object.keys(actual)).toEqual(Object.keys(expected));
+      for (const key of Object.keys(expected)) {
+        expect(actual[key]).toBe(expected[key]);
+      }
+    });
+  }
+
+  test("Project and StatusPage carry billing-decorated columns; Monitor's dictionary is empty", () => {
+    expect(
+      Object.keys(getColumnBillingAccessControlForAllColumns(new Project()))
+        .length,
+    ).toBeGreaterThan(0);
+    expect(
+      Object.keys(getColumnBillingAccessControlForAllColumns(new StatusPage()))
+        .length,
+    ).toBeGreaterThan(0);
+    expect(getColumnBillingAccessControlForAllColumns(new Monitor())).toEqual(
+      {},
+    );
+  });
+
+  test("repeated calls return the same dictionary object", () => {
+    const project: Project = new Project();
+    const first: Dictionary<ColumnBillingAccessControl> =
+      getColumnBillingAccessControlForAllColumns(project);
+    const second: Dictionary<ColumnBillingAccessControl> =
+      getColumnBillingAccessControlForAllColumns(new Project());
+
+    expect(second).toBe(first);
+  });
+
+  test("second call performs zero Reflect metadata reads", () => {
+    const project: Project = new Project();
+    getColumnBillingAccessControlForAllColumns(project); // warm the cache
+
+    const spy: jest.SpyInstance = jest.spyOn(Reflect, "getMetadata");
+    try {
+      getColumnBillingAccessControlForAllColumns(project);
+      expect(spy).not.toHaveBeenCalled();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("different classes get distinct dictionaries", () => {
+    const statusPageBilling: Dictionary<ColumnBillingAccessControl> =
+      getColumnBillingAccessControlForAllColumns(new StatusPage());
+    const projectBilling: Dictionary<ColumnBillingAccessControl> =
+      getColumnBillingAccessControlForAllColumns(new Project());
+
+    expect(statusPageBilling).not.toBe(projectBilling);
+    expect(Object.keys(statusPageBilling)).not.toEqual(
+      Object.keys(projectBilling),
+    );
+  });
+
+  test("model getColumnBillingAccessControl reads without mutating the cached dictionary", () => {
+    const project: Project = new Project();
+    const expected: Dictionary<ColumnBillingAccessControl> =
+      rebuildBillingAccessControl(project);
+    const keysBefore: Array<string> = Object.keys(
+      getColumnBillingAccessControlForAllColumns(project),
+    );
+
+    for (const key of keysBefore) {
+      expect(project.getColumnBillingAccessControl(key)).toBe(expected[key]);
+    }
+    expect(project.getColumnBillingAccessControl("doesNotExist")).toBe(
+      undefined,
+    );
+
+    expect(
+      Object.keys(getColumnBillingAccessControlForAllColumns(new Project())),
+    ).toEqual(keysBefore);
+  });
+});