@oneuptime/common 14.0.10 → 14.0.11

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

@@ -0,0 +1,473 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * A form tied to an incident template relies on IncidentService's template
+ * branch to apply the template: the initial state, the severity when none is
+ * set, the description when the reporter wrote none, the monitors, labels
+ * and status pages, a monitor status change, and the template's custom field
+ * values under the reporter's answers. That branch only runs for a create
+ * that sets no state and names the template by createdIncidentTemplateId -
+ * which is what IncidentFormService.submitPublicForm sends.
+ *
+ * The submission suite pins what submitPublicForm hands to
+ * IncidentService.create. This one closes the loop: it feeds exactly that
+ * incident to the REAL IncidentService.onBeforeCreate (the reads it makes
+ * are stubbed) and checks the incident that comes out - so a change on
+ * either side that stopped the template applying, or let it switch status
+ * page visibility back on, fails here.
+ */
+
+jest.mock("../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+    getLogAttributesFromRequest: jest.fn().mockReturnValue({}),
+  };
+});
+
+import Incident from "../../../Models/DatabaseModels/Incident";
+import IncidentCustomField from "../../../Models/DatabaseModels/IncidentCustomField";
+import IncidentForm from "../../../Models/DatabaseModels/IncidentForm";
+import IncidentState from "../../../Models/DatabaseModels/IncidentState";
+import IncidentTemplate from "../../../Models/DatabaseModels/IncidentTemplate";
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import IncidentFormRateLimit from "../../../Server/Middleware/IncidentFormRateLimit";
+import CustomFieldMappingService from "../../../Server/Services/CustomFieldMappingService";
+import IncidentCustomFieldService from "../../../Server/Services/IncidentCustomFieldService";
+import IncidentFormService from "../../../Server/Services/IncidentFormService";
+import IncidentFormSubmissionService from "../../../Server/Services/IncidentFormSubmissionService";
+import IncidentInternalNoteService from "../../../Server/Services/IncidentInternalNoteService";
+import IncidentService from "../../../Server/Services/IncidentService";
+import IncidentStateService from "../../../Server/Services/IncidentStateService";
+import IncidentTemplateOwnerTeamService from "../../../Server/Services/IncidentTemplateOwnerTeamService";
+import IncidentTemplateOwnerUserService from "../../../Server/Services/IncidentTemplateOwnerUserService";
+import IncidentTemplateService from "../../../Server/Services/IncidentTemplateService";
+import MonitorService from "../../../Server/Services/MonitorService";
+import ProjectService from "../../../Server/Services/ProjectService";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import { OnCreate } from "../../../Server/Types/Database/Hooks";
+import CaptchaUtil from "../../../Server/Utils/Captcha";
+import ProjectScopedReferenceValidator from "../../../Server/Utils/Database/ProjectScopedReferenceValidator";
+import CustomFieldMappingSourceResource from "../../../Types/CustomField/CustomFieldMappingSourceResource";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import {
+  IncidentFormFieldSetting,
+  PublicIncidentForm,
+  PublicIncidentFormField,
+  PublicIncidentFormSubmissionResult,
+} from "../../../Types/Incident/IncidentFormPublic";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+
+type OnBeforeCreate = (
+  createBy: CreateBy<Incident>,
+) => Promise<OnCreate<Incident>>;
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "5d7f3c0a-4c55-4d3e-9a3e-2d4a7d1c9f01",
+);
+const FORM_ID: string = "a1b2c3d4-0000-4000-8000-0000000000f1";
+const SHARE_KEY: string = "7c9e6679-7425-40de-944b-e07fc1f90ae7";
+const FORM_SEVERITY_ID: string = "b0000000-0000-4000-8000-0000000000f1";
+const TEMPLATE_SEVERITY_ID: string = "b0000000-0000-4000-8000-0000000000f2";
+const TEMPLATE_ID: string = "c0000000-0000-4000-8000-0000000000f1";
+const TEMPLATE_STATE_ID: string = "d0000000-0000-4000-8000-0000000000f1";
+const TEMPLATE_MONITOR_STATUS_ID: string =
+  "d0000000-0000-4000-8000-0000000000f2";
+const MONITOR_ID: string = "e1000000-0000-4000-8000-0000000000f1";
+const LABEL_ID: string = "e2000000-0000-4000-8000-0000000000f1";
+const STATUS_PAGE_ID: string = "e3000000-0000-4000-8000-0000000000f1";
+
+function buildForm(): IncidentForm {
+  const form: IncidentForm = new IncidentForm();
+  form._id = FORM_ID;
+  form.projectId = PROJECT_ID;
+  form.name = "Report a Problem";
+  form.isEnabled = true;
+  form.shareKey = new ObjectID(SHARE_KEY);
+  form.incidentSeverityId = new ObjectID(FORM_SEVERITY_ID);
+  form.incidentTemplateId = new ObjectID(TEMPLATE_ID);
+  form.allowReporterToChooseSeverity = false;
+  form.descriptionSetting = IncidentFormFieldSetting.Optional;
+  form.customFieldSettings = { impact: "Required", region: "Optional" };
+  form.isReporterDetailsRequired = false;
+  form.ipWhitelist = "";
+  return form;
+}
+
+function customField(
+  name: string,
+  variableKey: string,
+  sortOrder: number,
+): IncidentCustomField {
+  const field: IncidentCustomField = new IncidentCustomField();
+  field.name = name;
+  field.variableKey = variableKey;
+  field.customFieldType = CustomFieldType.Text;
+  field.sortOrder = sortOrder;
+  return field;
+}
+
+function buildTemplate(): IncidentTemplate {
+  const template: IncidentTemplate = new IncidentTemplate();
+  template._id = TEMPLATE_ID;
+  template.initialIncidentStateId = new ObjectID(TEMPLATE_STATE_ID);
+  template.incidentSeverityId = new ObjectID(TEMPLATE_SEVERITY_ID);
+  template.changeMonitorStatusToId = new ObjectID(TEMPLATE_MONITOR_STATUS_ID);
+  template.title = "Template title the reporter's replaces";
+  template.description = "The template's own description.";
+
+  const monitor: Monitor = new Monitor();
+  monitor._id = MONITOR_ID;
+  template.monitors = [monitor];
+
+  const label: Label = new Label();
+  label._id = LABEL_ID;
+  template.labels = [label];
+
+  const statusPage: StatusPage = new StatusPage();
+  statusPage._id = STATUS_PAGE_ID;
+  template.statusPages = [statusPage];
+
+  template.customFields = {
+    Impact: "Unknown",
+    Runbook: "https://runbooks.example/checkout",
+  };
+
+  return template;
+}
+
+let storedForm: IncidentForm;
+let declared: Incident | null;
+
+beforeEach(() => {
+  storedForm = buildForm();
+  declared = null;
+
+  // What submitPublicForm reads.
+  jest
+    .spyOn(IncidentFormService, "findOneBy")
+    .mockImplementation((async (): Promise<IncidentForm> => {
+      return storedForm;
+    }) as never);
+  jest
+    .spyOn(IncidentFormService, "isProjectOnPlan")
+    .mockResolvedValue(true as never);
+  jest.spyOn(CaptchaUtil, "isCaptchaEnabled").mockReturnValue(false);
+  // The form's hourly ceiling lives in Redis, which this suite has none of.
+  jest
+    .spyOn(IncidentFormRateLimit, "reserveFormSubmission")
+    .mockResolvedValue(undefined as never);
+  jest
+    .spyOn(IncidentCustomFieldService, "findBy")
+    .mockResolvedValue([
+      customField("Impact", "impact", 1),
+      customField("Region", "region", 2),
+      customField("Runbook", "runbook", 3),
+    ] as never);
+  jest
+    .spyOn(IncidentTemplateOwnerUserService, "findBy")
+    .mockResolvedValue([] as never);
+  jest
+    .spyOn(IncidentTemplateOwnerTeamService, "findBy")
+    .mockResolvedValue([] as never);
+  jest
+    .spyOn(IncidentFormSubmissionService, "create")
+    .mockImplementation((async (createBy: { data: unknown }) => {
+      return createBy.data;
+    }) as never);
+  jest
+    .spyOn(IncidentInternalNoteService, "create")
+    .mockImplementation((async (createBy: { data: unknown }) => {
+      return createBy.data;
+    }) as never);
+
+  // What the real IncidentService.onBeforeCreate reads.
+  jest
+    .spyOn(IncidentTemplateService, "findOneBy")
+    .mockResolvedValue(buildTemplate() as never);
+  jest
+    .spyOn(IncidentStateService, "findOneBy")
+    .mockImplementation((async (findBy: {
+      query: Record<string, unknown>;
+    }): Promise<IncidentState> => {
+      const state: IncidentState = new IncidentState();
+      state._id =
+        findBy.query["isCreatedState"] === true
+          ? "d0000000-0000-4000-8000-0000000000aa"
+          : String(findBy.query["_id"]);
+      return state;
+    }) as never);
+  jest
+    .spyOn(ProjectScopedReferenceValidator, "validateReferencesBelongToProject")
+    .mockResolvedValue(undefined as never);
+  jest
+    .spyOn(ProjectService, "incrementAndGetIncidentCounter")
+    .mockResolvedValue({ counter: 7, prefix: "INC-" } as never);
+  jest
+    .spyOn(CustomFieldMappingService, "applyMappingsToCreate")
+    .mockResolvedValue(undefined as never);
+
+  /*
+   * The create itself runs the real hook on what submitPublicForm sends,
+   * and hands back what the hook made of it, as the database would.
+   */
+  jest.spyOn(IncidentService, "create").mockImplementation((async (
+    createBy: CreateBy<Incident>,
+  ): Promise<Incident> => {
+    const onCreate: OnCreate<Incident> = await (
+      IncidentService as unknown as { onBeforeCreate: OnBeforeCreate }
+    ).onBeforeCreate(createBy);
+
+    declared = onCreate.createBy.data;
+    declared._id = "f0000000-0000-4000-8000-0000000000f1";
+
+    return declared;
+  }) as never);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+function submit(
+  answers: JSONObject,
+): Promise<PublicIncidentFormSubmissionResult> {
+  return IncidentFormService.submitPublicForm({
+    shareKey: SHARE_KEY,
+    request: { data: answers } as never,
+    clientIp: "203.0.113.7",
+  });
+}
+
+function ids(
+  rows: Array<{ _id?: string | undefined }> | undefined,
+): Array<string> {
+  return (rows || []).map((row: { _id?: string | undefined }) => {
+    return String(row._id);
+  });
+}
+
+describe("a submission through a form with a template, through the real IncidentService hook", () => {
+  test("starts in the template's state and carries its monitors, labels, status pages and monitor status change", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared).not.toBeNull();
+    expect(declared!.currentIncidentStateId?.toString()).toBe(
+      TEMPLATE_STATE_ID,
+    );
+    expect(ids(declared!.monitors)).toEqual([MONITOR_ID]);
+    expect(ids(declared!.labels)).toEqual([LABEL_ID]);
+    expect(ids(declared!.statusPages)).toEqual([STATUS_PAGE_ID]);
+    expect(declared!.changeMonitorStatusToId?.toString()).toBe(
+      TEMPLATE_MONITOR_STATUS_ID,
+    );
+  });
+
+  test("keeps the reporter's title, and the form's severity over the template's", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.title).toBe("Checkout is down");
+    expect(declared!.incidentSeverityId?.toString()).toBe(FORM_SEVERITY_ID);
+  });
+
+  test("takes the template's severity when the form's own was deleted", async () => {
+    (storedForm as unknown as Record<string, unknown>)["incidentSeverityId"] =
+      null;
+
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.incidentSeverityId?.toString()).toBe(TEMPLATE_SEVERITY_ID);
+  });
+
+  test("takes the template's description when the reporter wrote none, and the reporter's when they did", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.description).toBe("The template's own description.");
+
+    await submit({
+      title: "Checkout is down",
+      description: "Orders fail at step 3.",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.description).toBe("Orders fail at step 3.");
+  });
+
+  test("lays the reporter's answers over the template's custom field values", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High", Region: "EU" },
+    });
+
+    expect(declared!.customFields).toEqual({
+      Impact: "High",
+      Region: "EU",
+      Runbook: "https://runbooks.example/checkout",
+    });
+  });
+
+  /*
+   * The template names status pages, which scopes the incident to them -
+   * and it still starts off every page and without notifying anybody,
+   * until a responder publishes it.
+   */
+  test("stays off the template's status pages, and notifies none of their subscribers", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.isScopedToStatusPages).toBe(true);
+    expect(declared!.isVisibleOnStatusPage).toBe(false);
+    expect(
+      declared!.shouldStatusPageSubscribersBeNotifiedOnIncidentCreated,
+    ).toBe(false);
+    expect(declared!.subscriberNotificationStatusOnIncidentCreated).toBe(
+      StatusPageSubscriberNotificationStatus.Skipped,
+    );
+  });
+
+  test("names no creating user and writes no root cause", async () => {
+    await submit({
+      title: "Checkout is down",
+      customFields: { Impact: "High" },
+    });
+
+    expect(declared!.createdByUserId).toBeUndefined();
+    expect(declared!.rootCause).toBeUndefined();
+  });
+
+  /*
+   * The mapping has the last word on a field copied from a monitor field,
+   * and the form's incident takes its template's monitors. Run with the
+   * real mapping: the page never asks such a field, an answer sent anyway
+   * is dropped, and the incident holds the monitor's value - where before
+   * the reporter was made to answer and the answer was silently replaced.
+   */
+  describe("a field copied from a monitor field", () => {
+    function vendorField(): IncidentCustomField {
+      const field: IncidentCustomField = customField("Vendor", "vendor", 4);
+      field.mapFromResourceType = CustomFieldMappingSourceResource.Monitor;
+      field.mapFromCustomFieldName = "Vendor";
+      return field;
+    }
+
+    beforeEach(() => {
+      jest
+        .spyOn(CustomFieldMappingService, "applyMappingsToCreate")
+        .mockRestore();
+
+      jest
+        .spyOn(IncidentCustomFieldService, "findBy")
+        .mockResolvedValue([
+          customField("Impact", "impact", 1),
+          customField("Region", "region", 2),
+          customField("Runbook", "runbook", 3),
+          vendorField(),
+        ] as never);
+
+      const monitor: Monitor = new Monitor();
+      monitor._id = MONITOR_ID;
+      monitor.customFields = { Vendor: "AWS" };
+
+      jest
+        .spyOn(MonitorService, "findBy")
+        .mockResolvedValue([monitor] as never);
+
+      storedForm.customFieldSettings = {
+        impact: "Required",
+        vendor: "Required",
+      };
+    });
+
+    test("is not asked, and the incident takes the template monitor's value over an answer sent anyway", async () => {
+      const publicForm: PublicIncidentForm =
+        await IncidentFormService.getPublicForm({
+          shareKey: SHARE_KEY,
+          clientIp: "203.0.113.7",
+        });
+
+      expect(
+        publicForm.customFields.map((field: PublicIncidentFormField) => {
+          return field.name;
+        }),
+      ).toEqual(["Impact"]);
+
+      await submit({
+        title: "Checkout is down",
+        customFields: { Impact: "High", Vendor: "Azure" },
+      });
+
+      expect(declared!.customFields).toEqual({
+        Impact: "High",
+        Runbook: "https://runbooks.example/checkout",
+        Vendor: "AWS",
+      });
+    });
+
+    test("is asked, and the reporter's answer kept, on a form without a template", async () => {
+      (storedForm as unknown as Record<string, unknown>)["incidentTemplateId"] =
+        null;
+
+      const publicForm: PublicIncidentForm =
+        await IncidentFormService.getPublicForm({
+          shareKey: SHARE_KEY,
+          clientIp: "203.0.113.7",
+        });
+
+      expect(
+        publicForm.customFields.map((field: PublicIncidentFormField) => {
+          return field.name;
+        }),
+      ).toEqual(["Impact", "Vendor"]);
+
+      await submit({
+        title: "Checkout is down",
+        customFields: { Impact: "High", Vendor: "Azure" },
+      });
+
+      expect(declared!.customFields).toEqual({
+        Impact: "High",
+        Vendor: "Azure",
+      });
+    });
+  });
+
+  test("tells the reporter the number the project gave the incident", async () => {
+    expect(
+      await submit({
+        title: "Checkout is down",
+        customFields: { Impact: "High" },
+      }),
+    ).toEqual({ incidentNumber: "INC-7" });
+    expect(declared!.incidentNumber).toBe(7);
+  });
+});

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

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { replaceAllLiterally } from "../../../Server/Services/IncidentGroupingEngineService";
+
+/*
+ * Episode title and description templates are filled with an incident's
+ * title, description, first monitor's name and severity. A string
+ * replacement reads "$&", "$`", "$'" and "$1" in the value as patterns, so a
+ * title such as "Price $& up" came out of an episode template mangled - and a
+ * title typed on an incident form could copy other parts of the template into
+ * itself. replaceAllLiterally puts every value in exactly as written.
+ */
+describe("replaceAllLiterally", () => {
+  test.each([
+    ["$&", "Price $& up"],
+    ["$`", "Before $` after"],
+    ["$'", "Before $' after"],
+    ["$1", "Group $1 down"],
+    ["$$", "Cost $$ high"],
+  ])(
+    "puts a value holding %s in exactly as written",
+    (_label: string, value: string) => {
+      expect(
+        replaceAllLiterally(
+          "Episode: {{incidentTitle}} ({{incidentTitle}})",
+          /\{\{incidentTitle\}\}/g,
+          value,
+        ),
+      ).toBe(`Episode: ${value} (${value})`);
+    },
+  );
+
+  test("replaces every occurrence of the placeholder", () => {
+    expect(
+      replaceAllLiterally(
+        "{{monitorName}} / {{monitorName}} / {{monitorName}}",
+        /\{\{monitorName\}\}/g,
+        "api",
+      ),
+    ).toBe("api / api / api");
+  });
+
+  test("leaves text without the placeholder unchanged", () => {
+    expect(
+      replaceAllLiterally(
+        "No placeholders here",
+        /\{\{incidentTitle\}\}/g,
+        "anything",
+      ),
+    ).toBe("No placeholders here");
+  });
+});
+
+describe("IncidentGroupingEngineService's template substitution", () => {
+  const source: string = fs
+    .readFileSync(
+      path.resolve(
+        __dirname,
+        "../../../Server/Services/IncidentGroupingEngineService.ts",
+      ),
+      "utf8",
+    )
+    .replace(/\s+/g, "");
+
+  test.each([
+    ["incidentTitle", "incident.title"],
+    ["incidentDescription", "incident.description"],
+    ["monitorName", "incident.monitors[0].name"],
+    ["incidentSeverity", "incident.incidentSeverity.name"],
+  ])(
+    "puts {{%s}} in literally, in both the render and the preprocess step",
+    (placeholder: string, value: string) => {
+      const literal: string = `replaceAllLiterally(result,/\\{\\{${placeholder}\\}\\}/g,${value},)`;
+      const asPattern: string = `result.replace(/\\{\\{${placeholder}\\}\\}/g,${value}`;
+
+      expect(source.split(literal).length - 1).toBe(2);
+      expect(source).not.toContain(asPattern);
+    },
+  );
+});