@oneuptime/common 13.0.8 → 14.0.1

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

@@ -14,6 +14,7 @@ import UpdateBy from "../../../Server/Types/Database/UpdateBy";
 import logger from "../../../Server/Utils/Logger";
 import URL from "../../../Types/API/URL";
 import ObjectID from "../../../Types/ObjectID";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
 
 /*
@@ -21,8 +22,8 @@ import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
  * to notice an SLO's monitor rules went stale. The engine is covered
  * separately; what matters here is that something actually calls it.
  *
- *   - MonitorService, when a monitor's labels, name or description change.
- *     SLO monitor rules match on all three, so a rename can pull a monitor
+ *   - MonitorService, when a monitor's labels, type, name or description change.
+ *     SLO monitor rules match on all four, so a rename can pull a monitor
  *     into an SLO or push it out. Keyed on the field being present rather
  *     than non-empty, because clearing every label arrives as `[]` and is
  *     exactly the edit that should detach the monitor.
@@ -129,6 +130,24 @@ describe("MonitorService.onUpdateSuccess - keeping SLO monitor rules honest", ()
     jest.restoreAllMocks();
   });
 
+  it("re-runs SLO rules for every affected monitor when its type changes", async () => {
+    await callHook(
+      MonitorService,
+      "onUpdateSuccess",
+      monitorUpdate({ monitorType: MonitorType.API }),
+      [MONITOR_ID, OTHER_MONITOR_ID],
+    );
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledTimes(2);
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledWith({
+      monitorId: MONITOR_ID,
+      projectId: PROJECT_ID,
+    });
+    expect(syncSlosForMonitorSpy).toHaveBeenCalledWith({
+      monitorId: OTHER_MONITOR_ID,
+      projectId: PROJECT_ID,
+    });
+  });
+
   it("re-runs the SLO monitor rules when a monitor gains a label", async () => {
     await callHook(
       MonitorService,

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

@@ -0,0 +1,480 @@
+import Entities from "../../../Models/DatabaseModels/Index";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import ServiceLevelObjective from "../../../Models/DatabaseModels/ServiceLevelObjective";
+import ServiceLevelObjectiveMonitorRule from "../../../Models/DatabaseModels/ServiceLevelObjectiveMonitorRule";
+import PostgresAppInstance from "../../../Server/Infrastructure/PostgresDatabase";
+import AuditLogService from "../../../Server/Services/AuditLogService";
+import MonitorService from "../../../Server/Services/MonitorService";
+import ServiceLevelObjectiveFeedService from "../../../Server/Services/ServiceLevelObjectiveFeedService";
+import ServiceLevelObjectiveMonitorRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleEngineService";
+import ServiceLevelObjectiveMonitorRuleService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleService";
+import ServiceLevelObjectiveService from "../../../Server/Services/ServiceLevelObjectiveService";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import RuleCriteria, {
+  RULE_CRITERIA_SCHEMA_VERSION,
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+} from "../../../Types/Rules/RuleCriteria";
+import { DataSource } from "typeorm";
+
+/*
+ * Opt in with RUN_POSTGRES_SLO_MONITOR_TYPE_TESTS=true and config.env.
+ * The database must already be migrated. Only table structures are copied
+ * into a unique schema; every fixture and membership write stays there.
+ * Persistence, validation, rule hooks and the engine use production services.
+ * Only unrelated feed, audit and workflow delivery is replaced.
+ */
+const describePostgres: typeof describe =
+  process.env["RUN_POSTGRES_SLO_MONITOR_TYPE_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+function criteria(
+  filters: Array<RuleCriteriaFilter>,
+  filterCondition: FilterCondition = FilterCondition.All,
+): RuleCriteria {
+  return {
+    schemaVersion: RULE_CRITERIA_SCHEMA_VERSION,
+    filterCondition,
+    filters,
+  };
+}
+
+function typeFilter(
+  monitorType: MonitorType,
+  operator: RuleCriteriaOperator = RuleCriteriaOperator.Equals,
+): RuleCriteriaFilter {
+  return { field: "monitorType", operator, value: monitorType };
+}
+
+describePostgres("SLO monitor type rules against Postgres", () => {
+  const schema: string = `slo_monitor_type_${ObjectID.generate().toString().replace(/-/g, "")}`;
+  const projectId: ObjectID = ObjectID.generate();
+  const otherProjectId: ObjectID = ObjectID.generate();
+  const tables: Array<string> = [
+    "Monitor",
+    "Label",
+    "MonitorLabel",
+    "ServiceLevelObjective",
+    "ServiceLevelObjectiveMonitor",
+    "ServiceLevelObjectiveAutoAddedMonitor",
+    "ServiceLevelObjectiveMonitorLabel",
+    "ServiceLevelObjectiveMonitorRule",
+    "ServiceLevelObjectiveMonitorRuleMonitorLabel",
+  ];
+  let database: DataSource;
+  let sloId: ObjectID;
+  let apiId: ObjectID;
+  let websiteId: ObjectID;
+  let otherProjectApiId: ObjectID;
+
+  beforeAll(async () => {
+    database = new DataSource({
+      type: "postgres",
+      host: process.env["SLO_MONITOR_TYPE_TEST_DATABASE_HOST"] || "localhost",
+      port: Number(
+        process.env["SLO_MONITOR_TYPE_TEST_DATABASE_PORT"] || "5400",
+      ),
+      username: process.env["DATABASE_USERNAME"] || "postgres",
+      password: process.env["DATABASE_PASSWORD"] || "password",
+      database:
+        process.env["SLO_MONITOR_TYPE_TEST_DATABASE_NAME"] ||
+        process.env["DATABASE_NAME"] ||
+        "oneuptimedb",
+      entities: Entities,
+      schema,
+      synchronize: false,
+      extra: { options: `-c search_path=${schema},public` },
+    });
+    await database.initialize();
+    await database.query(`CREATE SCHEMA "${schema}"`);
+    for (const table of tables) {
+      await database.query(
+        `CREATE TABLE "${schema}"."${table}" (LIKE public."${table}" INCLUDING ALL)`,
+      );
+    }
+
+    jest.spyOn(PostgresAppInstance, "isConnected").mockReturnValue(true);
+    jest.spyOn(PostgresAppInstance, "getDataSource").mockReturnValue(database);
+    jest.spyOn(AuditLogService, "recordCreate").mockResolvedValue();
+    jest.spyOn(AuditLogService, "recordUpdate").mockResolvedValue();
+    jest
+      .spyOn(
+        ServiceLevelObjectiveFeedService,
+        "createServiceLevelObjectiveFeedItem",
+      )
+      .mockResolvedValue();
+    jest
+      .spyOn(ServiceLevelObjectiveMonitorRuleService, "onTriggerWorkflow")
+      .mockResolvedValue();
+    jest
+      .spyOn(ServiceLevelObjectiveService, "onTriggerWorkflow")
+      .mockResolvedValue();
+  });
+
+  beforeEach(async () => {
+    await database.query(
+      `TRUNCATE ${tables
+        .map((table: string): string => {
+          return `"${schema}"."${table}"`;
+        })
+        .join(", ")}`,
+    );
+    sloId = await seedSlo(projectId);
+    apiId = await seedMonitor(MonitorType.API, "api-production", projectId);
+    websiteId = await seedMonitor(
+      MonitorType.Website,
+      "website-production",
+      projectId,
+    );
+    otherProjectApiId = await seedMonitor(
+      MonitorType.API,
+      "api-production",
+      otherProjectId,
+    );
+  });
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+    if (database?.isInitialized) {
+      await database.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+      await database.destroy();
+    }
+  });
+
+  async function seedSlo(ownerProjectId: ObjectID): Promise<ObjectID> {
+    const id: ObjectID = ObjectID.generate();
+    await database.query(
+      `INSERT INTO "${schema}"."ServiceLevelObjective"
+       ("_id", "projectId", "name", "slug", "targetPercentage", "version")
+       VALUES ($1, $2, 'Synthetic SLO', $3, 99.9, 1)`,
+      [id.toString(), ownerProjectId.toString(), `slo-type-${id.toString()}`],
+    );
+    return id;
+  }
+
+  async function seedMonitor(
+    monitorType: MonitorType,
+    name: string,
+    ownerProjectId: ObjectID,
+  ): Promise<ObjectID> {
+    const id: ObjectID = ObjectID.generate();
+    await database.query(
+      `INSERT INTO "${schema}"."Monitor"
+       ("_id", "projectId", "name", "description", "slug", "monitorType", "currentMonitorStatusId", "version")
+       VALUES ($1, $2, $3, 'Customer facing production service', $4, $5, $6, 1)`,
+      [
+        id.toString(),
+        ownerProjectId.toString(),
+        name,
+        `monitor-type-${id.toString()}`,
+        monitorType,
+        ObjectID.generate().toString(),
+      ],
+    );
+    return id;
+  }
+
+  async function createRule(
+    ruleCriteria: RuleCriteria,
+    targetSloId: ObjectID = sloId,
+    ownerProjectId: ObjectID = projectId,
+  ): Promise<ServiceLevelObjectiveMonitorRule> {
+    const rule: ServiceLevelObjectiveMonitorRule =
+      new ServiceLevelObjectiveMonitorRule();
+    rule.projectId = ownerProjectId;
+    rule.serviceLevelObjectiveId = targetSloId;
+    rule.name = "Synthetic type rule";
+    rule.isEnabled = true;
+    rule.criteria = ruleCriteria;
+    return ServiceLevelObjectiveMonitorRuleService.create({
+      data: rule,
+      props: { isRoot: true },
+    });
+  }
+
+  async function expectMembership(
+    attachedIds: Array<ObjectID>,
+    autoAddedIds: Array<ObjectID> = attachedIds,
+    targetSloId: ObjectID = sloId,
+  ): Promise<void> {
+    const slo: ServiceLevelObjective | null =
+      await ServiceLevelObjectiveService.findOneById({
+        id: targetSloId,
+        select: { monitors: { _id: true }, autoAddedMonitors: { _id: true } },
+        props: { isRoot: true },
+      });
+    expect(slo).not.toBeNull();
+    const ids: (monitors: Array<Monitor> | undefined) => Array<string> = (
+      monitors: Array<Monitor> | undefined,
+    ): Array<string> => {
+      return (monitors || [])
+        .map((monitor: Monitor): string => {
+          return monitor.id!.toString();
+        })
+        .sort();
+    };
+    expect(ids(slo!.monitors)).toEqual(attachedIds.map(String).sort());
+    expect(ids(slo!.autoAddedMonitors)).toEqual(
+      autoAddedIds.map(String).sort(),
+    );
+  }
+
+  test("round-trips a type criterion and backfills only matching monitors in the SLO's project", async () => {
+    const savedCriteria: RuleCriteria = criteria([typeFilter(MonitorType.API)]);
+    const rule: ServiceLevelObjectiveMonitorRule =
+      await createRule(savedCriteria);
+    const stored: ServiceLevelObjectiveMonitorRule | null =
+      await ServiceLevelObjectiveMonitorRuleService.findOneById({
+        id: rule.id!,
+        select: { criteria: true, monitorType: true },
+        props: { isRoot: true },
+      });
+
+    expect(stored?.criteria).toEqual(savedCriteria);
+    await expectMembership([apiId]);
+    await expect(
+      ServiceLevelObjectiveMonitorRuleEngineService.syncMonitorsForSlo({
+        serviceLevelObjectiveId: sloId,
+      }),
+    ).resolves.toEqual({ monitorIdsAdded: [], monitorIdsRemoved: [] });
+  });
+
+  test("editing Equals to NotEquals persists the new operator and replaces automatic membership", async () => {
+    const rule: ServiceLevelObjectiveMonitorRule = await createRule(
+      criteria([typeFilter(MonitorType.API)]),
+    );
+    const updatedCriteria: RuleCriteria = criteria([
+      typeFilter(MonitorType.API, RuleCriteriaOperator.NotEquals),
+    ]);
+    await ServiceLevelObjectiveMonitorRuleService.updateOneById({
+      id: rule.id!,
+      data: { criteria: updatedCriteria },
+      props: { isRoot: true },
+    });
+    const rows: Array<{ criteria: RuleCriteria }> = await database.query(
+      `SELECT "criteria" FROM "${schema}"."ServiceLevelObjectiveMonitorRule" WHERE "_id" = $1`,
+      [rule.id!.toString()],
+    );
+    expect(rows[0]?.criteria).toEqual(updatedCriteria);
+    await expectMembership([websiteId]);
+  });
+
+  test("the nullable type column supports legacy type-only rules and existing rules without a type", async () => {
+    const rule: ServiceLevelObjectiveMonitorRule =
+      new ServiceLevelObjectiveMonitorRule();
+    rule.projectId = projectId;
+    rule.serviceLevelObjectiveId = sloId;
+    rule.name = "Legacy type rule";
+    rule.isEnabled = true;
+    rule.monitorType = MonitorType.API;
+    const created: ServiceLevelObjectiveMonitorRule =
+      await ServiceLevelObjectiveMonitorRuleService.create({
+        data: rule,
+        props: { isRoot: true },
+      });
+    const stored: ServiceLevelObjectiveMonitorRule | null =
+      await ServiceLevelObjectiveMonitorRuleService.findOneById({
+        id: created.id!,
+        select: { monitorType: true, criteria: true },
+        props: { isRoot: true },
+      });
+    expect(stored?.monitorType).toBe(MonitorType.API);
+    expect(stored?.criteria).toBeNull();
+    await expectMembership([apiId]);
+
+    const columns: Array<{
+      is_nullable: string;
+      column_default: string | null;
+    }> = await database.query(
+      `SELECT is_nullable, column_default FROM information_schema.columns
+         WHERE table_schema = $1 AND table_name = 'ServiceLevelObjectiveMonitorRule' AND column_name = 'monitorType'`,
+      [schema],
+    );
+    expect(columns).toEqual([{ is_nullable: "YES", column_default: null }]);
+
+    await ServiceLevelObjectiveMonitorRuleService.updateOneById({
+      id: created.id!,
+      data: {
+        criteria: criteria([
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.MatchesPattern,
+            value: "^website-",
+          },
+        ]),
+      },
+      props: { isRoot: true },
+    });
+    await expectMembership([websiteId]);
+  });
+
+  test("Match all and Match any combine a persisted type with positive and negative text patterns", async () => {
+    const filters: Array<RuleCriteriaFilter> = [
+      typeFilter(MonitorType.API),
+      {
+        field: "monitorNamePattern",
+        operator: RuleCriteriaOperator.MatchesPattern,
+        value: "^website-",
+      },
+      {
+        field: "monitorDescriptionPattern",
+        operator: RuleCriteriaOperator.DoesNotMatchPattern,
+        value: "production",
+      },
+    ];
+    const rule: ServiceLevelObjectiveMonitorRule = await createRule(
+      criteria(filters),
+    );
+    await expectMembership([]);
+
+    await ServiceLevelObjectiveMonitorRuleService.updateOneById({
+      id: rule.id!,
+      data: { criteria: criteria(filters, FilterCondition.Any) },
+      props: { isRoot: true },
+    });
+    await expectMembership([apiId, websiteId]);
+
+    await ServiceLevelObjectiveMonitorRuleService.updateOneById({
+      id: rule.id!,
+      data: {
+        criteria: criteria([
+          typeFilter(MonitorType.API),
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.MatchesPattern,
+            value: "^api-",
+          },
+          {
+            field: "monitorDescriptionPattern",
+            operator: RuleCriteriaOperator.DoesNotMatchPattern,
+            value: "staging",
+          },
+        ]),
+      },
+      props: { isRoot: true },
+    });
+    await expectMembership([apiId]);
+  });
+
+  test("monitor-side type changes attach and detach automatic members while preserving manual membership", async () => {
+    await database.query(
+      `INSERT INTO "${schema}"."ServiceLevelObjectiveMonitor" ("serviceLevelObjectiveId", "monitorId") VALUES ($1, $2)`,
+      [sloId.toString(), websiteId.toString()],
+    );
+    await createRule(criteria([typeFilter(MonitorType.API)]));
+    await expectMembership([apiId, websiteId], [apiId]);
+
+    await MonitorService.updateColumnsByIdWithoutHooks({
+      id: apiId,
+      data: { monitorType: MonitorType.Website },
+    });
+    await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor({
+      monitorId: apiId,
+    });
+    await expectMembership([websiteId], []);
+
+    await MonitorService.updateColumnsByIdWithoutHooks({
+      id: websiteId,
+      data: { monitorType: MonitorType.API },
+    });
+    await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor({
+      monitorId: websiteId,
+    });
+    await expectMembership([websiteId], []);
+
+    await MonitorService.updateColumnsByIdWithoutHooks({
+      id: websiteId,
+      data: { monitorType: MonitorType.Website },
+    });
+    await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor({
+      monitorId: websiteId,
+    });
+    await expectMembership([websiteId], []);
+
+    await MonitorService.updateColumnsByIdWithoutHooks({
+      id: apiId,
+      data: { monitorType: MonitorType.API },
+    });
+    await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor({
+      monitorId: apiId,
+    });
+    await expectMembership([apiId, websiteId], [apiId]);
+  });
+
+  test("a type change in another project cannot attach its monitor to this SLO", async () => {
+    const otherSloId: ObjectID = await seedSlo(otherProjectId);
+    await createRule(criteria([typeFilter(MonitorType.API)]));
+    await createRule(
+      criteria([typeFilter(MonitorType.Website)]),
+      otherSloId,
+      otherProjectId,
+    );
+    await expectMembership([], [], otherSloId);
+
+    await MonitorService.updateColumnsByIdWithoutHooks({
+      id: otherProjectApiId,
+      data: { monitorType: MonitorType.Website },
+    });
+    await ServiceLevelObjectiveMonitorRuleEngineService.syncSlosForMonitor({
+      monitorId: otherProjectApiId,
+    });
+    await expectMembership(
+      [otherProjectApiId],
+      [otherProjectApiId],
+      otherSloId,
+    );
+    await expectMembership([apiId]);
+  });
+
+  test("disabling the type rule removes its persisted automatic membership", async () => {
+    const rule: ServiceLevelObjectiveMonitorRule = await createRule(
+      criteria([typeFilter(MonitorType.API)]),
+    );
+    await expectMembership([apiId]);
+    await ServiceLevelObjectiveMonitorRuleService.updateOneById({
+      id: rule.id!,
+      data: { isEnabled: false },
+      props: { isRoot: true },
+    });
+    await expectMembership([]);
+  });
+
+  test.each([
+    {
+      field: "monitorType",
+      operator: RuleCriteriaOperator.Equals,
+      value: "not-a-monitor-type",
+    },
+    {
+      field: "monitorType",
+      operator: RuleCriteriaOperator.Contains,
+      value: MonitorType.API,
+    },
+  ])(
+    "rejects invalid type criteria before changing stored rules or membership: %j",
+    async (filter: RuleCriteriaFilter) => {
+      const rule: ServiceLevelObjectiveMonitorRule = await createRule(
+        criteria([typeFilter(MonitorType.API)]),
+      );
+      await expect(createRule(criteria([filter]))).rejects.toThrow();
+      await expect(
+        ServiceLevelObjectiveMonitorRuleService.updateOneById({
+          id: rule.id!,
+          data: { criteria: criteria([filter]) },
+          props: { isRoot: true },
+        }),
+      ).rejects.toThrow();
+      const rows: Array<{ criteria: RuleCriteria }> = await database.query(
+        `SELECT "criteria" FROM "${schema}"."ServiceLevelObjectiveMonitorRule"`,
+      );
+      expect(rows).toHaveLength(1);
+      expect(rows[0]?.criteria).toEqual(
+        criteria([typeFilter(MonitorType.API)]),
+      );
+      await expectMembership([apiId]);
+    },
+  );
+});

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

@@ -17,7 +17,9 @@ import IncidentStateTimelineService from "../../../Server/Services/IncidentState
 import MonitorStatusService from "../../../Server/Services/MonitorStatusService";
 import ServiceLevelObjectiveService from "../../../Server/Services/ServiceLevelObjectiveService";
 import ServiceLevelObjectiveBurnRateRuleService from "../../../Server/Services/ServiceLevelObjectiveBurnRateRuleService";
+import ServiceLevelObjectiveLabelRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveLabelRuleEngineService";
 import ServiceLevelObjectiveMonitorRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveMonitorRuleEngineService";
+import ServiceLevelObjectiveOwnerRuleEngineService from "../../../Server/Services/ServiceLevelObjectiveOwnerRuleEngineService";
 import ServiceLevelObjectiveOwnerTeamService from "../../../Server/Services/ServiceLevelObjectiveOwnerTeamService";
 import ServiceLevelObjectiveOwnerUserService from "../../../Server/Services/ServiceLevelObjectiveOwnerUserService";
 import TeamMemberService from "../../../Server/Services/TeamMemberService";
@@ -2554,3 +2556,163 @@ describe("ServiceLevelObjectiveService - applying the monitor rules", () => {
     expect(syncMonitorsForSloSpy).not.toHaveBeenCalled();
   });
 });
+
+/*
+ * SLO label and owner rules fire when an SLO is created, like every other
+ * resource's: label rules first, so an owner rule can key on a label a label
+ * rule just attached, and without holding up - or ever failing - the create.
+ */
+describe("ServiceLevelObjectiveService - applying the label and owner rules", () => {
+  let labelRulesSpy: jest.SpyInstance;
+  let ownerRulesSpy: jest.SpyInstance;
+  let errorSpy: jest.SpyInstance;
+
+  // The rules run off the request path; let them.
+  async function settle(): Promise<void> {
+    for (let i: number = 0; i < 10; i++) {
+      await new Promise((resolve: (value: unknown) => void) => {
+        setTimeout(resolve, 0);
+      });
+    }
+  }
+
+  function createdSlo(): ServiceLevelObjective {
+    return makeSlo({
+      _id: SLO_ID.toString(),
+      id: SLO_ID,
+      projectId: PROJECT_ID,
+      targetPercentage: 99.9,
+    });
+  }
+
+  function onCreateSuccess(
+    createdItem: ServiceLevelObjective,
+  ): Promise<unknown> {
+    return callHook(
+      "onCreateSuccess",
+      {
+        createBy: makeCreateBy({
+          projectId: PROJECT_ID,
+          targetPercentage: 99.9,
+        }),
+        carryForward: null,
+      },
+      createdItem,
+    );
+  }
+
+  beforeEach(() => {
+    labelRulesSpy = jest
+      .spyOn(
+        ServiceLevelObjectiveLabelRuleEngineService,
+        "applyRulesToServiceLevelObjective",
+      )
+      .mockResolvedValue(undefined);
+    ownerRulesSpy = jest
+      .spyOn(
+        ServiceLevelObjectiveOwnerRuleEngineService,
+        "applyRulesToServiceLevelObjective",
+      )
+      .mockResolvedValue(undefined);
+    errorSpy = jest.spyOn(logger, "error").mockImplementation(() => {});
+
+    jest
+      .spyOn(
+        ServiceLevelObjectiveMonitorRuleEngineService,
+        "syncMonitorsForSlo",
+      )
+      .mockResolvedValue({ monitorIdsAdded: [], monitorIdsRemoved: [] });
+    jest
+      .spyOn(ServiceLevelObjectiveService, "updateOneById")
+      .mockResolvedValue(1);
+    jest
+      .spyOn(ServiceLevelObjectiveService, "findOneById")
+      .mockResolvedValue(makeSlo({ projectId: PROJECT_ID }));
+    jest.spyOn(AlertSeverityService, "findOneBy").mockResolvedValue(null);
+    jest
+      .spyOn(ServiceLevelObjectiveBurnRateRuleService, "create")
+      .mockResolvedValue(makeBurnRateRule(RULE_ID));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("applies the label rules, then the owner rules, to the SLO it created", async () => {
+    const createdItem: ServiceLevelObjective = createdSlo();
+
+    await onCreateSuccess(createdItem);
+    await settle();
+
+    expect(labelRulesSpy).toHaveBeenCalledTimes(1);
+    expect(labelRulesSpy).toHaveBeenCalledWith(createdItem);
+    expect(ownerRulesSpy).toHaveBeenCalledTimes(1);
+    expect(ownerRulesSpy).toHaveBeenCalledWith(createdItem);
+    expect(labelRulesSpy.mock.invocationCallOrder[0]!).toBeLessThan(
+      ownerRulesSpy.mock.invocationCallOrder[0]!,
+    );
+  });
+
+  // So an owner rule sees the labels the label rules just attached.
+  it("starts the owner rules only once the label rules have finished", async () => {
+    let finishLabelRules: () => void = () => {};
+    labelRulesSpy.mockReturnValue(
+      new Promise<void>((resolve: () => void) => {
+        finishLabelRules = resolve;
+      }),
+    );
+
+    await onCreateSuccess(createdSlo());
+    await settle();
+
+    expect(labelRulesSpy).toHaveBeenCalledTimes(1);
+    expect(ownerRulesSpy).not.toHaveBeenCalled();
+
+    finishLabelRules();
+    await settle();
+
+    expect(ownerRulesSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not hold up the create while the rules run", async () => {
+    labelRulesSpy.mockReturnValue(
+      new Promise<void>(() => {
+        // Never settles.
+      }),
+    );
+    const createdItem: ServiceLevelObjective = createdSlo();
+
+    await expect(onCreateSuccess(createdItem)).resolves.toBe(createdItem);
+  });
+
+  it("never fails the create when the rules cannot be applied, and logs why", async () => {
+    labelRulesSpy.mockRejectedValue(new Error("database is down"));
+    const createdItem: ServiceLevelObjective = createdSlo();
+
+    await expect(onCreateSuccess(createdItem)).resolves.toBe(createdItem);
+    await settle();
+
+    const messages: Array<string> = errorSpy.mock.calls.map(
+      (call: Array<unknown>): string => {
+        return String(call[0]);
+      },
+    );
+    expect(
+      messages.some((message: string): boolean => {
+        return (
+          message.includes("label and owner rules") &&
+          message.includes(SLO_ID.toString()) &&
+          message.includes("database is down")
+        );
+      }),
+    ).toBe(true);
+  });
+
+  it("applies no rules to an SLO that has no id", async () => {
+    await onCreateSuccess(makeSlo({ projectId: PROJECT_ID }));
+    await settle();
+
+    expect(labelRulesSpy).not.toHaveBeenCalled();
+    expect(ownerRulesSpy).not.toHaveBeenCalled();
+  });
+});