@oneuptime/common 14.0.8 → 14.0.10

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

@@ -0,0 +1,282 @@
+import AIService, {
+  AI_BALANCE_INSUFFICIENT_MESSAGE,
+  AI_DISABLED_MESSAGE,
+} from "../../../Server/Services/AIService";
+import KubernetesClusterAiAccessService, {
+  KubernetesClusterAiAccessProjectGates,
+} from "../../../Server/Services/KubernetesClusterAiAccessService";
+import LlmProviderService from "../../../Server/Services/LlmProviderService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import LlmProvider from "../../../Models/DatabaseModels/LlmProvider";
+import Project from "../../../Models/DatabaseModels/Project";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — AIService.getAiBalanceBlocker, the ONE predicate
+ * behind "out of AI credits": the cluster AI status's ai_balance_insufficient
+ * gap and the investigation not-started reason both ask it, so the two never
+ * disagree with each other or with the refusal executeWithLogging makes on
+ * the call itself.
+ *
+ * A blocker exists only when ALL of these hold: billing is on, the
+ * project's resolved LLM provider is the OneUptime-hosted (global) one with
+ * a per-token cost, the balance is at or below zero, and auto-recharge is
+ * off (a project with auto-recharge is topped up when it runs low).
+ * Everything else — a free global provider, the project's own provider, no
+ * provider at all (its own gap), a positive balance — is no blocker.
+ */
+
+type MockBillingGlobal = typeof globalThis & {
+  __oneuptimeBalanceBlockerTestBillingEnabled: boolean;
+};
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  const actual: Record<string, unknown> = jest.requireActual(
+    "../../../Server/EnvironmentConfig",
+  ) as Record<string, unknown>;
+  const mocked: Record<string, unknown> = { ...actual };
+  const mockGlobal: MockBillingGlobal = globalThis as MockBillingGlobal;
+  mockGlobal.__oneuptimeBalanceBlockerTestBillingEnabled = true;
+
+  Object.defineProperty(mocked, "IsBillingEnabled", {
+    configurable: true,
+    enumerable: true,
+    get: (): boolean => {
+      return mockGlobal.__oneuptimeBalanceBlockerTestBillingEnabled;
+    },
+  });
+
+  return mocked;
+});
+
+function setBillingEnabled(value: boolean): void {
+  (
+    globalThis as MockBillingGlobal
+  ).__oneuptimeBalanceBlockerTestBillingEnabled = value;
+}
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+
+function provider(overrides: Record<string, unknown> = {}): LlmProvider {
+  return {
+    id: ObjectID.generate(),
+    isGlobalLlm: true,
+    costPerMillionTokensInUSDCents: 500,
+    ...overrides,
+  } as unknown as LlmProvider;
+}
+
+function project(overrides: Record<string, unknown> = {}): Project {
+  return {
+    aiCurrentBalanceInUSDCents: 0,
+    enableAutoRechargeAiBalance: false,
+    ...overrides,
+  } as unknown as Project;
+}
+
+describe("AIService.getAiBalanceBlocker", () => {
+  let providerLookup: jest.SpyInstance;
+  let projectLookup: jest.SpyInstance;
+
+  beforeEach(() => {
+    setBillingEnabled(true);
+    providerLookup = jest
+      .spyOn(LlmProviderService, "getLLMProviderForProject")
+      .mockResolvedValue(provider());
+    projectLookup = jest
+      .spyOn(ProjectService, "findOneById")
+      .mockResolvedValue(project());
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    setBillingEnabled(true);
+  });
+
+  it("blocks when billing is on, the provider is the paid global one, the balance is empty and auto-recharge is off", async () => {
+    expect(await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID })).toBe(
+      AI_BALANCE_INSUFFICIENT_MESSAGE,
+    );
+  });
+
+  it("blocks a negative balance too", async () => {
+    projectLookup.mockResolvedValue(
+      project({ aiCurrentBalanceInUSDCents: -250 }),
+    );
+
+    expect(await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID })).toBe(
+      AI_BALANCE_INSUFFICIENT_MESSAGE,
+    );
+  });
+
+  it("blocks a balance that was never set (read as zero, like the call itself reads it)", async () => {
+    projectLookup.mockResolvedValue(
+      project({ aiCurrentBalanceInUSDCents: undefined }),
+    );
+
+    expect(await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID })).toBe(
+      AI_BALANCE_INSUFFICIENT_MESSAGE,
+    );
+  });
+
+  it("reads the balance and auto-recharge of THIS project, as root", async () => {
+    await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID });
+
+    expect(projectLookup).toHaveBeenCalledWith({
+      id: PROJECT_ID,
+      select: {
+        aiCurrentBalanceInUSDCents: true,
+        enableAutoRechargeAiBalance: true,
+      },
+      props: { isRoot: true },
+    });
+    expect(providerLookup).toHaveBeenCalledWith(PROJECT_ID);
+  });
+
+  it("no blocker when billing is off (self-hosted): nothing is metered", async () => {
+    setBillingEnabled(false);
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+    expect(providerLookup).not.toHaveBeenCalled();
+    expect(projectLookup).not.toHaveBeenCalled();
+  });
+
+  it("no blocker when auto-recharge is on", async () => {
+    projectLookup.mockResolvedValue(
+      project({ enableAutoRechargeAiBalance: true }),
+    );
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+  });
+
+  it("no blocker while the balance is positive", async () => {
+    projectLookup.mockResolvedValue(project({ aiCurrentBalanceInUSDCents: 1 }));
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+  });
+
+  it("no blocker for the project's own provider: it bills the project's own account", async () => {
+    providerLookup.mockResolvedValue(provider({ isGlobalLlm: false }));
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+    expect(projectLookup).not.toHaveBeenCalled();
+  });
+
+  it("no blocker for a free global provider (no per-token cost)", async () => {
+    for (const cost of [0, undefined, null]) {
+      providerLookup.mockResolvedValue(
+        provider({ costPerMillionTokensInUSDCents: cost }),
+      );
+
+      expect(
+        await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+      ).toBeNull();
+    }
+  });
+
+  it("no blocker when there is no provider at all: that is its own gap", async () => {
+    providerLookup.mockResolvedValue(null);
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+  });
+
+  it("no blocker for a project row that cannot be found", async () => {
+    projectLookup.mockResolvedValue(null);
+
+    expect(
+      await AIService.getAiBalanceBlocker({ projectId: PROJECT_ID }),
+    ).toBeNull();
+  });
+
+  it("uses a provider the caller already resolved instead of looking it up again", async () => {
+    expect(
+      await AIService.getAiBalanceBlocker({
+        projectId: PROJECT_ID,
+        llmProvider: provider(),
+      }),
+    ).toBe(AI_BALANCE_INSUFFICIENT_MESSAGE);
+    expect(
+      await AIService.getAiBalanceBlocker({
+        projectId: PROJECT_ID,
+        llmProvider: null,
+      }),
+    ).toBeNull();
+    expect(providerLookup).not.toHaveBeenCalled();
+  });
+
+  it("the reason is one plain sentence a person can act on", () => {
+    expect(AI_BALANCE_INSUFFICIENT_MESSAGE).toBe(
+      "This project's AI credit balance is used up and auto-recharge is off, so OneUptime AI cannot run.",
+    );
+  });
+});
+
+/*
+ * The cluster AI status resolves the project's provider for its
+ * llm_provider_missing gap and hands it to this predicate, so a status
+ * build looks the provider up once. Billing is on here, so the predicate
+ * really runs: a second lookup inside it would show as a second call.
+ */
+describe("KubernetesClusterAiAccessService.getProjectGates and the balance predicate", () => {
+  let providerLookup: jest.SpyInstance;
+
+  beforeEach(() => {
+    setBillingEnabled(true);
+    providerLookup = jest
+      .spyOn(LlmProviderService, "getLLMProviderForProject")
+      .mockResolvedValue(provider());
+    jest.spyOn(ProjectService, "findOneById").mockResolvedValue(project());
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    setBillingEnabled(true);
+  });
+
+  it("looks the provider up once and still reports the empty balance", async () => {
+    const gates: KubernetesClusterAiAccessProjectGates =
+      await KubernetesClusterAiAccessService.getProjectGates(PROJECT_ID);
+
+    expect(providerLookup).toHaveBeenCalledTimes(1);
+    expect(gates.hasLlmProvider).toBe(true);
+    expect(gates.aiBalanceBlocker).toBe(AI_BALANCE_INSUFFICIENT_MESSAGE);
+  });
+
+  it("negative control: a funded balance is no blocker, still with one lookup", async () => {
+    (
+      ProjectService.findOneById as unknown as jest.SpyInstance
+    ).mockResolvedValue(project({ aiCurrentBalanceInUSDCents: 5000 }));
+
+    const gates: KubernetesClusterAiAccessProjectGates =
+      await KubernetesClusterAiAccessService.getProjectGates(PROJECT_ID);
+
+    expect(providerLookup).toHaveBeenCalledTimes(1);
+    expect(gates.aiBalanceBlocker).toBeNull();
+  });
+});
+
+describe("AI_DISABLED_MESSAGE", () => {
+  /*
+   * The Enable AI switch lives on the always-visible Project Settings → AI
+   * Features page now; AI Credits is hidden on self-hosted installs.
+   */
+  it("points at Project Settings → AI Features, never AI Credits", () => {
+    expect(AI_DISABLED_MESSAGE).toBe(
+      "AI features are disabled for this project. Enable them in Project Settings → AI Features.",
+    );
+    expect(AI_DISABLED_MESSAGE).not.toContain("AI Credits");
+  });
+});

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

@@ -0,0 +1,409 @@
+import AlertService from "../../../Server/Services/AlertService";
+import CustomFieldMappingService from "../../../Server/Services/CustomFieldMappingService";
+import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
+import ProjectScopedReferenceValidator from "../../../Server/Utils/Database/ProjectScopedReferenceValidator";
+import Entities from "../../../Models/DatabaseModels/Index";
+import Alert from "../../../Models/DatabaseModels/Alert";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import { DataSource, EntityMetadata } from "typeorm";
+import { Subject } from "typeorm/persistence/Subject";
+import { SubjectChangedColumnsComputer } from "typeorm/persistence/SubjectChangedColumnsComputer";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+
+/*
+ * Clearing an alert's monitor in the dashboard has to store NULL, not leave
+ * the old monitor in place. The path, end to end:
+ *
+ *   1. EntityDropdown's Clear selection hands the form null, and ModelForm
+ *      submits it: BaseModel.toJSON keeps a null column (it drops only
+ *      undefined ones), JSONFunctions.serialize keeps null, and the PUT body
+ *      carries `monitor: null` (EventOverviewPages.test.tsx renders that
+ *      form and checks the body).
+ *   2. BaseAPI.updateItem deserializes the body (null stays null) and hands
+ *      it to updateOneById as it is.
+ *   3. DatabaseService._updateBy: sanitizeCreateOrUpdate only turns id
+ *      strings into relation stubs and leaves null alone. The Affected
+ *      Resources payload carries many-to-many lists, so it is written with
+ *      repository.save(); a monitor-only payload with repository.update().
+ *      -> the service tests below, with the real hooks.
+ *   4. TypeORM resolves the `monitor` relation to its join column, monitorId,
+ *      and a null relation to an empty parameter - on both paths, since
+ *      save() builds its UPDATE from the same value set - and node-postgres
+ *      sends an empty parameter as SQL NULL. -> the library tests at the
+ *      top, which pin the behaviour so an upgrade that changed it fails here.
+ */
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "0193c0de-eeee-4aaa-8bbb-000000000001",
+);
+const ALERT_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000a1";
+const OLD_MONITOR_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000b1";
+const NEW_MONITOR_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000b2";
+const HOST_ID: string = "0193c0de-eeee-4aaa-8bbb-0000000000d1";
+
+type PrepareValueFunction = (value: unknown) => unknown;
+
+// The members of the service these tests stub that its type keeps private.
+interface HookedAlertService {
+  _findBy: (...args: Array<unknown>) => Promise<unknown>;
+  onUpdateSuccess: (...args: Array<unknown>) => Promise<unknown>;
+}
+
+const hookedAlertService: HookedAlertService =
+  AlertService as unknown as HookedAlertService;
+
+describe("TypeORM and node-postgres write a cleared monitor as NULL", () => {
+  let database: DataSource;
+
+  beforeAll(async () => {
+    database = new DataSource({
+      type: "postgres",
+      entities: Entities,
+      synchronize: false,
+    });
+
+    await (
+      database as unknown as { buildMetadatas: () => Promise<void> }
+    ).buildMetadatas();
+  });
+
+  /*
+   * The statement repository.update() runs for this SET. Typed loosely: the
+   * model's columns are declared without null, which is exactly the value
+   * under test.
+   */
+  function updateStatementFor(set: JSONObject): [string, Array<unknown>] {
+    return database
+      .createQueryBuilder()
+      .update(Alert)
+      .set(set as unknown as QueryDeepPartialEntity<Alert>)
+      .where({ _id: ALERT_ID })
+      .getQueryAndParameters();
+  }
+
+  // The parameter the statement binds to "monitorId".
+  function monitorIdParameter(statement: [string, Array<unknown>]): unknown {
+    const match: RegExpMatchArray | null = statement[0].match(
+      /"monitorId" = \$(\d+)/,
+    );
+
+    expect(match).not.toBeNull();
+
+    return statement[1][Number(match![1]) - 1];
+  }
+
+  test("the monitor relation is the monitorId column", () => {
+    const metadata: EntityMetadata = database.getMetadata(Alert);
+
+    expect(
+      metadata
+        .findColumnsWithPropertyPath("monitor")
+        .map((column: { databaseName: string }): string => {
+          return column.databaseName;
+        }),
+    ).toEqual(["monitorId"]);
+  });
+
+  test("update() with the relation cleared sets monitorId to an empty parameter", () => {
+    expect(monitorIdParameter(updateStatementFor({ monitor: null }))).toBe(
+      undefined,
+    );
+  });
+
+  test("update() with the column cleared sets it to null", () => {
+    expect(monitorIdParameter(updateStatementFor({ monitorId: null }))).toBe(
+      null,
+    );
+  });
+
+  test("update() with a relation object sets the monitor's id", () => {
+    expect(
+      monitorIdParameter(
+        updateStatementFor({
+          monitor: { _id: NEW_MONITOR_ID },
+        }),
+      ),
+    ).toBe(NEW_MONITOR_ID);
+  });
+
+  test("node-postgres sends an empty or null parameter as SQL NULL", () => {
+    const prepareValue: PrepareValueFunction = (
+      jest.requireActual("pg/lib/utils") as {
+        prepareValue: PrepareValueFunction;
+      }
+    ).prepareValue;
+
+    expect(prepareValue(undefined)).toBeNull();
+    expect(prepareValue(null)).toBeNull();
+  });
+
+  /*
+   * save() diffs the entity against the stored row and builds its UPDATE
+   * from the change map. For the monitor that is the same {monitor: null} the
+   * update() path writes.
+   */
+  function changedValuesForSave(entity: JSONObject): JSONObject {
+    const subject: Subject = new Subject({
+      metadata: database.getMetadata(Alert),
+      entity: entity,
+      canBeInserted: false,
+      canBeUpdated: true,
+      mustBeRemoved: false,
+    });
+
+    // As SubjectDatabaseEntityLoader loads it: the relation as its id map.
+    subject.databaseEntity = {
+      _id: ALERT_ID,
+      monitorId: OLD_MONITOR_ID,
+      monitor: { _id: OLD_MONITOR_ID },
+    };
+    subject.databaseEntityLoaded = true;
+
+    new SubjectChangedColumnsComputer().compute([subject]);
+
+    return subject.createValueSetAndPopChangeMap() as JSONObject;
+  }
+
+  test("save() with the relation cleared writes {monitor: null}, so monitorId = NULL", () => {
+    const changed: JSONObject = changedValuesForSave({
+      _id: ALERT_ID,
+      monitor: null,
+      hosts: [],
+    });
+
+    expect(changed).toEqual({ monitor: null });
+    expect(monitorIdParameter(updateStatementFor(changed))).toBeUndefined();
+  });
+
+  test("save() with the monitor it already has writes nothing for it", () => {
+    expect(
+      changedValuesForSave({
+        _id: ALERT_ID,
+        monitor: { _id: OLD_MONITOR_ID },
+        hosts: [],
+      }),
+    ).toEqual({});
+  });
+
+  test("save() without the monitor key leaves the column alone", () => {
+    expect(changedValuesForSave({ _id: ALERT_ID, hosts: [] })).toEqual({});
+  });
+});
+
+/*
+ * The service half: the real AlertService hooks, with the database behind
+ * them stubbed (the rows the guard and the write locate, the repository the
+ * write goes to), so what reaches TypeORM is exactly what the hooks let
+ * through.
+ */
+describe("AlertService.updateOneById hands TypeORM the cleared monitor", () => {
+  let saveMock: MockFunction;
+  let updateMock: MockFunction;
+  let isCreatedAutomatically: boolean = false;
+  let storedMonitorId: string | null = OLD_MONITOR_ID;
+
+  // The Workflow "Update Alert" component writes this way; so can the API.
+  const ROOT_PROPS: DatabaseCommonInteractionProps = {
+    isRoot: true,
+    tenantId: PROJECT_ID,
+  };
+
+  function storedAlert(): Alert {
+    const alert: Alert = new Alert();
+    alert._id = ALERT_ID;
+    alert.projectId = PROJECT_ID;
+
+    if (storedMonitorId) {
+      alert.monitorId = new ObjectID(storedMonitorId);
+    }
+
+    alert.isCreatedAutomatically = isCreatedAutomatically;
+    return alert;
+  }
+
+  beforeEach(() => {
+    isCreatedAutomatically = false;
+    storedMonitorId = OLD_MONITOR_ID;
+
+    // The guard's read of the matched alerts.
+    jest.spyOn(AlertService, "findBy").mockImplementation((async (): Promise<
+      Array<Alert>
+    > => {
+      return [storedAlert()];
+    }) as never);
+
+    // The rows _updateBy locates for the write.
+    jest
+      .spyOn(hookedAlertService, "_findBy")
+      .mockImplementation((async (): Promise<Array<Alert>> => {
+        return [storedAlert()];
+      }) as never);
+
+    jest
+      .spyOn(
+        ProjectScopedReferenceValidator,
+        "validateReferencesBelongToProject",
+      )
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(ProjectScopedReferenceValidator, "getHeldRelationIds")
+      .mockResolvedValue(new Map() as never);
+    jest
+      .spyOn(CustomFieldMappingService, "applyMappingsToUpdate")
+      .mockResolvedValue(undefined as never);
+
+    // Feed, metrics and state changes are covered in AlertMonitorEditFeed.
+    jest.spyOn(hookedAlertService, "onUpdateSuccess").mockImplementation(((
+      onUpdate: unknown,
+    ): Promise<unknown> => {
+      return Promise.resolve(onUpdate);
+    }) as never);
+
+    saveMock = getJestMockFunction();
+    saveMock.mockImplementation((item: unknown) => {
+      return Promise.resolve(item);
+    });
+    updateMock = getJestMockFunction();
+    updateMock.mockImplementation(() => {
+      return Promise.resolve({ affected: 1 });
+    });
+
+    jest
+      .spyOn(AlertService, "getRepository")
+      .mockReturnValue({ save: saveMock, update: updateMock } as never);
+
+    jest
+      .spyOn(ModelPermission, "checkUpdatePermissionByModel")
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(ModelPermission, "checkUpdateQueryPermissions")
+      .mockImplementation(((
+        _modelType: unknown,
+        query: unknown,
+      ): Promise<unknown> => {
+        return Promise.resolve(query);
+      }) as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function update(data: JSONObject): Promise<number> {
+    return AlertService.updateOneById({
+      id: new ObjectID(ALERT_ID),
+      data: data as never,
+      props: ROOT_PROPS,
+    });
+  }
+
+  test("the Affected Resources modal's payload reaches save() with monitor: null", async () => {
+    // As BaseAPI.updateItem hands it over: the deserialized request body.
+    await update({
+      monitor: null,
+      hosts: [{ _id: HOST_ID }],
+      services: [],
+    });
+
+    expect(saveMock).toHaveBeenCalledTimes(1);
+    expect(updateMock).not.toHaveBeenCalled();
+
+    const saved: Record<string, unknown> = saveMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+
+    expect(Object.prototype.hasOwnProperty.call(saved, "monitor")).toBe(true);
+    expect(saved["monitor"]).toBeNull();
+    expect(saved["_id"]).toBe(ALERT_ID);
+  });
+
+  test("a monitor-only payload reaches update() with monitor: null", async () => {
+    await update({ monitor: null });
+
+    expect(saveMock).not.toHaveBeenCalled();
+    expect(updateMock).toHaveBeenCalledTimes(1);
+
+    const set: Record<string, unknown> = updateMock.mock.calls[0]![1] as Record<
+      string,
+      unknown
+    >;
+
+    expect(Object.prototype.hasOwnProperty.call(set, "monitor")).toBe(true);
+    expect(set["monitor"]).toBeNull();
+  });
+
+  test("an API payload clearing monitorId reaches update() with monitorId: null", async () => {
+    await update({ monitorId: null });
+
+    const set: Record<string, unknown> = updateMock.mock.calls[0]![1] as Record<
+      string,
+      unknown
+    >;
+
+    expect(set["monitorId"]).toBeNull();
+  });
+
+  test("moving the monitor reaches the write as a relation to the new one", async () => {
+    await update({ monitor: { _id: NEW_MONITOR_ID } });
+
+    const set: Record<string, unknown> = updateMock.mock.calls[0]![1] as Record<
+      string,
+      unknown
+    >;
+
+    expect((set["monitor"] as { _id: string })._id).toBe(NEW_MONITOR_ID);
+  });
+
+  test("for an alert its monitor raised, the clear is refused and nothing is written", async () => {
+    isCreatedAutomatically = true;
+
+    await expect(
+      update({ monitor: null, hosts: [], services: [] }),
+    ).rejects.toThrow(/cannot be changed or removed/);
+
+    expect(saveMock).not.toHaveBeenCalled();
+    expect(updateMock).not.toHaveBeenCalled();
+  });
+
+  test("for an automatic alert with no monitor, attaching one is refused and nothing is written", async () => {
+    isCreatedAutomatically = true;
+    storedMonitorId = null;
+
+    await expect(update({ monitor: { _id: NEW_MONITOR_ID } })).rejects.toThrow(
+      /a monitor cannot be attached to it/,
+    );
+
+    expect(saveMock).not.toHaveBeenCalled();
+    expect(updateMock).not.toHaveBeenCalled();
+  });
+
+  test("for an automatic alert with no monitor, the card's payload still saves the rest", async () => {
+    isCreatedAutomatically = true;
+    storedMonitorId = null;
+
+    // The Monitor field is hidden, but submitted with the null it loaded.
+    await update({ monitor: null, hosts: [{ _id: HOST_ID }], services: [] });
+
+    expect(saveMock).toHaveBeenCalledTimes(1);
+
+    const saved: Record<string, unknown> = saveMock.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+
+    expect(saved["monitor"]).toBeNull();
+    expect(saved["hosts"]).toBeDefined();
+  });
+});