@oneuptime/common 13.0.7 → 14.0.0

package/Tests/Server/Services/ProjectServiceAuditLogSettingsCache.test.ts

@@ -2,8 +2,9 @@ import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
 import ObjectID from "../../../Types/ObjectID";
 
 /*
- * AuditLogService caches each project's audit settings (enabled, retention,
- * system events, plan) for a minute. Nothing ever invalidated that cache, so
+ * The audit-log recorder (Enterprise Edition, behind core's AuditLogService)
+ * caches each project's audit settings (enabled, retention, system events,
+ * plan) for a minute. Nothing ever invalidated that cache, so
  * for up to a minute after an admin turned audit logging on, the process that
  * saved the setting went on recording nothing - exactly when someone is
  * watching the empty audit page to check that it works. ProjectService now
@@ -34,10 +35,14 @@ jest.mock(
 
 import AuditLogService from "../../../Server/Services/AuditLogService";
 import ProjectService from "../../../Server/Services/ProjectService";
-import Monitor from "../../../Models/DatabaseModels/Monitor";
 import Project from "../../../Models/DatabaseModels/Project";
 import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
-import UserType from "../../../Types/UserType";
+import {
+  createAuditLogRecorderSpy,
+  installFakeEnterpriseModule,
+  MockedAuditLogRecorder,
+  uninstallEnterpriseModule,
+} from "../Enterprise/FakeEnterpriseModule";
 
 type HookCallable = {
   onUpdateSuccess: (
@@ -65,9 +70,11 @@ const updateProject: UpdateProjectFunction = async (
 
 beforeEach(() => {
   jest.clearAllMocks();
+  uninstallEnterpriseModule();
 });
 
 afterEach(() => {
+  uninstallEnterpriseModule();
   jest.restoreAllMocks();
 });
 
@@ -135,42 +142,31 @@ describe("ProjectService invalidates the audit log settings cache", () => {
     expect(invalidate).toHaveBeenCalledTimes(1);
   });
 
-  test("the next audit write in this process reads the new setting", async () => {
+  /*
+   * The cache itself lives in the Enterprise audit-log recorder (ee/), so
+   * "the next write reads the new setting" is pinned there, end to end
+   * (ee/Tests/Server/AuditLog/AuditLogSettingsInvalidation.test.ts). What
+   * core owns is that the invalidation reaches whichever recorder is
+   * registered, and is harmless when none is.
+   */
+  test("the invalidation reaches the Enterprise audit-log recorder", async () => {
+    const recorder: MockedAuditLogRecorder = createAuditLogRecorderSpy();
+    installFakeEnterpriseModule({ auditLogRecorder: recorder });
+
     const projectId: ObjectID = ObjectID.generate();
-    const project: Project = new Project();
-    project._id = projectId.toString();
-    project.enableAuditLogs = true;
-
-    const findProject: jest.SpyInstance = jest
-      .spyOn(ProjectService, "findOneById")
-      .mockResolvedValue(project as never);
-    jest.spyOn(AuditLogService, "create").mockResolvedValue(undefined as never);
-
-    const monitor: Monitor = new Monitor();
-    monitor._id = ObjectID.generate().toString();
-    monitor.name = "Checkout API";
-
-    type RecordFunction = () => Promise<void>;
-
-    const recordMonitorCreate: RecordFunction = async (): Promise<void> => {
-      await AuditLogService.recordCreate({
-        model: new Monitor(),
-        createdItem: monitor,
-        // An API-key actor needs no user lookup.
-        props: { tenantId: projectId, userType: UserType.API },
-      });
-    };
 
-    await recordMonitorCreate();
-    await recordMonitorCreate();
+    await updateProject({ enableAuditLogs: false }, [projectId]);
 
-    // Cached: the second write did not read the project again.
-    expect(findProject).toHaveBeenCalledTimes(1);
+    expect(recorder.invalidateProjectSettings).toHaveBeenCalledTimes(1);
+    expect(recorder.invalidateProjectSettings).toHaveBeenCalledWith(projectId);
+  });
 
-    await updateProject({ enableAuditLogs: false }, [projectId]);
-    await recordMonitorCreate();
+  test("on the Community Edition there is no cache to drop, and the update still succeeds", async () => {
+    uninstallEnterpriseModule();
 
-    expect(findProject).toHaveBeenCalledTimes(2);
+    await expect(
+      updateProject({ enableAuditLogs: true }, [ObjectID.generate()]),
+    ).resolves.toBeUndefined();
   });
 
   test("a failure to invalidate never fails the project update", async () => {

package/Tests/Server/Services/ProjectServiceCreateSubscriptionStarted.test.ts

@@ -513,13 +513,89 @@ describe("ProjectService project creation - subscription_started", () => {
       expect(spies.updateOneById).toHaveBeenCalled();
       expect(spies.emitInBackground).toHaveBeenCalled();
 
+      // The last write is the one carrying the subscription ids.
       const writeOrder: number =
-        spies.updateOneById.mock.invocationCallOrder[0]!;
+        spies.updateOneById.mock.invocationCallOrder[
+          spies.updateOneById.mock.invocationCallOrder.length - 1
+        ]!;
       const emitOrder: number =
         spies.emitInBackground.mock.invocationCallOrder[0]!;
 
       expect(emitOrder).toBeGreaterThan(writeOrder);
     });
+
+    it("should record the billing customer on the project before subscribing it to a plan", async () => {
+      /*
+       * Subscribing reports metered usage for the project, and that path
+       * finds the project's billing customer on this row. When the customer
+       * id was only written after subscribing, a paid-plan project had no
+       * customer on record at that moment and creation failed with 402.
+       */
+      const spies: CreateSpies = setup();
+
+      await createProject(fakeProject());
+
+      const customerWriteIndex: number =
+        spies.updateOneById.mock.calls.findIndex((call: Array<unknown>) => {
+          const data: Record<string, unknown> = (
+            call[0] as { data: Record<string, unknown> }
+          ).data;
+          return (
+            data["paymentProviderCustomerId"] === "cus_created_123" &&
+            data["paymentProviderSubscriptionId"] === undefined
+          );
+        });
+
+      expect(customerWriteIndex).toBeGreaterThan(-1);
+      expect(
+        spies.updateOneById.mock.calls[customerWriteIndex]![0],
+      ).toMatchObject({
+        id: PROJECT_ID,
+        props: { isRoot: true },
+      });
+
+      const customerWriteOrder: number =
+        spies.updateOneById.mock.invocationCallOrder[customerWriteIndex]!;
+      const subscribeOrder: number =
+        spies.subscribeToPlan.mock.invocationCallOrder[0]!;
+
+      expect(spies.createCustomer.mock.invocationCallOrder[0]!).toBeLessThan(
+        customerWriteOrder,
+      );
+      expect(customerWriteOrder).toBeLessThan(subscribeOrder);
+    });
+
+    it("should keep the billing customer recorded when subscribing fails", async () => {
+      const spies: CreateSpies = setup();
+      spies.subscribeToPlan.mockRejectedValue(new Error("stripe is down"));
+
+      await expect(createProject(fakeProject())).rejects.toThrow(
+        "stripe is down",
+      );
+
+      expect(spies.updateOneById).toHaveBeenCalledTimes(1);
+      expect(spies.updateOneById.mock.calls[0]![0]).toMatchObject({
+        data: { paymentProviderCustomerId: "cus_created_123" },
+      });
+      expect(spies.emitInBackground).not.toHaveBeenCalled();
+    });
+
+    it("should still write the subscription ids once subscribed", async () => {
+      const spies: CreateSpies = setup();
+
+      await createProject(fakeProject());
+
+      expect(spies.updateOneById).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          id: PROJECT_ID,
+          data: expect.objectContaining({
+            paymentProviderCustomerId: "cus_created_123",
+            paymentProviderSubscriptionId: "sub_main_created",
+            paymentProviderMeteredSubscriptionId: "sub_metered_created",
+          }),
+        }),
+      );
+    });
   });
 
   /*