@oneuptime/common 14.0.6 → 14.0.8

package/Tests/Server/Utils/VM/VMRunnerPrivateNetworkWiring.test.ts

@@ -81,6 +81,23 @@ describe("VMRunner — private network policy plumbing", () => {
     );
   });
 
+  test("the caller decides how much a DNS-decided refusal says", () => {
+    /*
+     * The probe passes false; the workflow caller passes nothing and gets the
+     * deployment default. Dropping it here would hand every script the
+     * detailed refusal on a shared probe.
+     */
+    expect(runnerSource).toMatch(
+      /includeResolutionDetailInError:\s*\n?\s*options\.includeResolutionDetailInError/,
+    );
+    expect(runnerSource).toMatch(
+      /includeResolutionDetailInError\?:\s*boolean \| undefined;/,
+    );
+    expect(apiSource).toMatch(
+      /includeResolutionDetailInError\?:\s*boolean \| undefined;/,
+    );
+  });
+
   test("there is exactly one call to the guard", () => {
     /*
      * A second, unguarded request path inside the runner would be invisible to

package/Tests/Server/Utils/VM/VMRunnerSsrf.test.ts

@@ -16,6 +16,7 @@ import http from "http";
 import https from "https";
 import { AddressInfo } from "net";
 import { gzipSync } from "zlib";
+import { startEachTestOnSelfHostedEgressPolicy } from "../EgressPolicyEnvironment";
 
 /*
  * Common's jsdom resolver selects Axios's browser bundle. VMRunner is a
@@ -46,6 +47,7 @@ jest.setTimeout(60000);
 interface SandboxPrivateNetworkOptions {
   allowPrivateNetworkRequests?: boolean | undefined;
   privateNetworkAccessIsAllowed?: boolean | undefined;
+  includeResolutionDetailInError?: boolean | undefined;
 }
 
 interface RunningLoopbackServer {
@@ -675,6 +677,79 @@ describe("VMRunner sandbox axios bridge — private network policy", () => {
   );
 });
 
+/*
+ * A script sees the guard's refusal verbatim. If "no such name" and "that name
+ * is internal" read differently, a script is a DNS oracle for the network the
+ * sandbox runs in: the API server's on SaaS, a shared probe's for the custom
+ * code monitor.
+ */
+describe("VMRunner sandbox axios bridge — DNS refusal detail", () => {
+  startEachTestOnSelfHostedEgressPolicy();
+
+  const internalNameRequest: string = `
+    try {
+      await axios.get('http://redis:6379/');
+      return 'request reached transport';
+    } catch (error) {
+      return 'request failed: ' + error.message;
+    }
+  `;
+
+  async function refusalsForMissingAndInternalName(
+    policy: SandboxPrivateNetworkOptions,
+  ): Promise<{ missing: string; internal: string }> {
+    const lookupSpy: ValidationLookupSpy = jest.spyOn(
+      dns.promises,
+      "lookup",
+    ) as unknown as ValidationLookupSpy;
+
+    lookupSpy.mockRejectedValue(new Error("getaddrinfo ENOTFOUND redis"));
+    const missing: string = await errorFromSandbox(internalNameRequest, policy);
+
+    lookupSpy.mockResolvedValue([{ address: "10.96.0.9", family: 4 }]);
+    const internal: string = await errorFromSandbox(
+      internalNameRequest,
+      policy,
+    );
+
+    return { missing, internal };
+  }
+
+  test("the probe's opt-out makes a missing and an internal name indistinguishable", async () => {
+    const { missing, internal } = await refusalsForMissingAndInternalName({
+      includeResolutionDetailInError: false,
+    });
+
+    expect(missing).toContain("Request URL could not be reached.");
+    expect(internal).toBe(missing);
+    expect(internal).not.toContain("10.96.0.9");
+  });
+
+  test("on SaaS a workflow script gets the same single refusal by default", async () => {
+    process.env["BILLING_ENABLED"] = "true";
+
+    const { missing, internal } = await refusalsForMissingAndInternalName({
+      allowPrivateNetworkRequests: true,
+    });
+
+    expect(missing).toContain("Request URL could not be reached.");
+    expect(internal).toBe(missing);
+  });
+
+  test("a self-hosted workflow script still gets the detailed refusal", async () => {
+    const { missing, internal } = await refusalsForMissingAndInternalName({
+      allowPrivateNetworkRequests: true,
+    });
+
+    expect(missing).toContain(
+      "Request URL hostname could not be resolved via DNS.",
+    );
+    expect(internal).toContain(
+      "Request URL resolves to a private network address and is not allowed.",
+    );
+  });
+});
+
 describe("VMRunner sandbox axios bridge — bounded host I/O", () => {
   const allowLoopbackForWorkflow: SandboxPrivateNetworkOptions = {
     allowPrivateNetworkRequests: true,

package/Tests/Types/CustomField/CustomFieldSavedViews.test.ts

@@ -0,0 +1,247 @@
+import {
+  CUSTOM_FIELD_COLUMN_ID_PREFIX,
+  CUSTOM_FIELD_FACET_KEY_PREFIX,
+  INCIDENT_CUSTOM_FIELD_TABLE_VIEW_IDS,
+  RenamedCustomFieldSavedViewState,
+  renameCustomFieldInSavedView,
+} from "../../../Types/CustomField/CustomFieldSavedViews";
+import { getCustomFieldColumns } from "../../../UI/Components/ModelTable/CustomFieldColumns";
+import Columns from "../../../UI/Components/ModelTable/Columns";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * A saved table view remembers custom fields by name: a column id
+ * "customFields.<name>" in its layout, a chip "customField:<name>" in its
+ * facets, and (should a table ever filter on one) query.customFields.<name>.
+ * Renaming a field has to rewrite exactly those, and nothing else, or the
+ * view silently loses the column and the chip.
+ */
+
+const FACETS: JSONObject = {
+  selectedOwnerKeys: ["user:abc"],
+  selectedLabelIds: ["label-1"],
+  ownerOperator: "is",
+  labelOperator: "is",
+  facetSelections: {
+    "customField:Impact": ["High"],
+    "customField:Region": ["East"],
+    currentIncidentState: ["state-1"],
+  },
+  facetOperators: {
+    "customField:Impact": "isNot",
+    currentIncidentState: "is",
+  },
+};
+
+const COLUMNS: JSONObject = {
+  order: ["title", "customFields.Impact", "customFields.Region"],
+  hidden: ["customFields.Impact", "labels"],
+};
+
+describe("renameCustomFieldInSavedView", () => {
+  test("renames the field's column, chip and operator, and keeps the rest", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS, query: { title: "x" } },
+        oldName: "Impact",
+        newName: "Business Impact",
+      });
+
+    expect(renamed.hasChanged).toBe(true);
+    expect(renamed.changes.columns).toEqual({
+      order: ["title", "customFields.Business Impact", "customFields.Region"],
+      hidden: ["customFields.Business Impact", "labels"],
+    });
+    expect(renamed.changes.facets).toEqual({
+      ...FACETS,
+      facetSelections: {
+        "customField:Business Impact": ["High"],
+        "customField:Region": ["East"],
+        currentIncidentState: ["state-1"],
+      },
+      facetOperators: {
+        "customField:Business Impact": "isNot",
+        currentIncidentState: "is",
+      },
+    });
+    // The query does not name the field, so it is not rewritten.
+    expect(renamed.changes.query).toBeUndefined();
+  });
+
+  test("keeps the chip where it was among the others", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(
+      Object.keys(
+        (renamed.changes.facets!["facetSelections"] as JSONObject) || {},
+      ),
+    ).toEqual([
+      "customField:Severity",
+      "customField:Region",
+      "currentIncidentState",
+    ]);
+  });
+
+  test("does not change the objects it was given", () => {
+    const facets: JSONObject = JSON.parse(JSON.stringify(FACETS));
+    const columns: JSONObject = JSON.parse(JSON.stringify(COLUMNS));
+
+    renameCustomFieldInSavedView({
+      view: { facets, columns },
+      oldName: "Impact",
+      newName: "Severity",
+    });
+
+    expect(facets).toEqual(FACETS);
+    expect(columns).toEqual(COLUMNS);
+  });
+
+  test("renames a filter on the field in the table's own query", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          query: {
+            title: "outage",
+            customFields: { Impact: "High", Region: "East" },
+          },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.changes.query).toEqual({
+      title: "outage",
+      customFields: { Severity: "High", Region: "East" },
+    });
+  });
+
+  test("the renamed field wins over a stale entry under the new name", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: {
+            facetSelections: {
+              "customField:Severity": ["stale"],
+              "customField:Impact": ["High"],
+            },
+          },
+          columns: {
+            order: ["customFields.Severity", "customFields.Impact"],
+            hidden: [],
+          },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.changes.facets!["facetSelections"]).toEqual({
+      "customField:Severity": ["High"],
+    });
+    expect(renamed.changes.columns!["order"]).toEqual([
+      "customFields.Severity",
+    ]);
+  });
+
+  test("a view that does not mention the field is left alone", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS, query: {} },
+        oldName: "Customer",
+        newName: "Client",
+      });
+
+    expect(renamed).toEqual({ changes: {}, hasChanged: false });
+  });
+
+  test("another field whose name merely contains the old one is not touched", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: {
+            facetSelections: { "customField:Impact Area": ["a"] },
+          },
+          columns: { order: ["customFields.Impact Area"], hidden: [] },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.hasChanged).toBe(false);
+  });
+
+  test("a name that is not a custom field's (no prefix) is not touched", () => {
+    const renamed: RenamedCustomFieldSavedViewState =
+      renameCustomFieldInSavedView({
+        view: {
+          facets: { facetSelections: { Impact: ["x"] } },
+          columns: { order: ["Impact"], hidden: ["Impact"] },
+        },
+        oldName: "Impact",
+        newName: "Severity",
+      });
+
+    expect(renamed.hasChanged).toBe(false);
+  });
+
+  test.each([
+    [{ facets: null, columns: null, query: null }],
+    [{ facets: { facetSelections: "broken" }, columns: { order: "broken" } }],
+    [{}],
+  ])(
+    "tolerates a view with nothing, or junk, where it looks (%j)",
+    (view: unknown) => {
+      expect(
+        renameCustomFieldInSavedView({
+          view: view as never,
+          oldName: "Impact",
+          newName: "Severity",
+        }).hasChanged,
+      ).toBe(false);
+    },
+  );
+
+  test.each([
+    ["Impact", "Impact"],
+    ["", "Severity"],
+    ["Impact", ""],
+  ])("does nothing for %j -> %j", (oldName: string, newName: string) => {
+    expect(
+      renameCustomFieldInSavedView({
+        view: { facets: FACETS, columns: COLUMNS },
+        oldName,
+        newName,
+      }).hasChanged,
+    ).toBe(false);
+  });
+});
+
+describe("the saved-view spellings match the table and the facet bar", () => {
+  test("a custom field column's id is the prefix and the name", () => {
+    const columns: Columns<Incident> = getCustomFieldColumns<Incident>({
+      definitions: [
+        { name: "Impact", customFieldType: CustomFieldType.Dropdown },
+      ],
+    });
+
+    expect(CUSTOM_FIELD_COLUMN_ID_PREFIX).toBe("customFields.");
+    expect(columns[0]!.id).toBe(`${CUSTOM_FIELD_COLUMN_ID_PREFIX}Impact`);
+  });
+
+  test("the facet chip prefix is the one the dashboard uses", () => {
+    expect(CUSTOM_FIELD_FACET_KEY_PREFIX).toBe("customField:");
+  });
+
+  test("the incidents list is a table whose saved views are rewritten", () => {
+    expect(INCIDENT_CUSTOM_FIELD_TABLE_VIEW_IDS).toContain(
+      "all-incidents-table",
+    );
+  });
+});

package/Tests/Types/CustomField/CustomFieldTemplateValues.test.ts

@@ -0,0 +1,186 @@
+import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
+import mergeTemplateCustomFieldsDefault, {
+  mergeTemplateCustomFields,
+} from "../../../Types/CustomField/CustomFieldTemplateMerge";
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import { keepValidCustomFieldValues } from "../../../Types/CustomField/CustomFieldValueValidator";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * An incident template's custom field values reach a new incident in two
+ * places: the server copies them when an incident is created with
+ * `createdIncidentTemplateId` (mergeTemplateCustomFields), and the dashboard
+ * starts the Create page from them (keepValidCustomFieldValues drops the
+ * stale ones first). Both merge into what the incident is given; neither
+ * ever replaces it.
+ */
+
+describe("mergeTemplateCustomFields", () => {
+  test("the template fills in the fields the incident does not set", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: { Impact: "High", Category: "Network" },
+        customFields: { Ticket: "OPS-7" },
+      }),
+    ).toEqual({ Impact: "High", Category: "Network", Ticket: "OPS-7" });
+  });
+
+  test("a value the incident sets always wins", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: { Impact: "High", Category: "Network" },
+        customFields: { Impact: "Low" },
+      }),
+    ).toEqual({ Impact: "Low", Category: "Network" });
+  });
+
+  test("0, false, null and empty from the incident are answers, not gaps", () => {
+    expect(
+      mergeTemplateCustomFields({
+        templateCustomFields: {
+          Count: 5,
+          Acknowledged: true,
+          Impact: "High",
+          Notes: "From the template",
+        },
+        customFields: {
+          Count: 0,
+          Acknowledged: false,
+          Impact: null,
+          Notes: "",
+        },
+      }),
+    ).toEqual({ Count: 0, Acknowledged: false, Impact: null, Notes: "" });
+  });
+
+  test("an incident with no custom fields gets the template's", () => {
+    for (const customFields of [undefined, null]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: { Impact: "High" },
+          customFields: customFields,
+        }),
+      ).toEqual({ Impact: "High" });
+    }
+  });
+
+  test("a template with no values changes nothing", () => {
+    for (const templateCustomFields of [undefined, null, {}, "x", [1]]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: templateCustomFields,
+          customFields: { Ticket: "OPS-7" },
+        }),
+      ).toBeUndefined();
+    }
+  });
+
+  test("custom fields that are not a bag are left exactly as sent", () => {
+    for (const customFields of ["High", 7, ["a"]]) {
+      expect(
+        mergeTemplateCustomFields({
+          templateCustomFields: { Impact: "High" },
+          customFields: customFields,
+        }),
+      ).toBeUndefined();
+    }
+  });
+
+  test("returns a new bag, leaving both inputs untouched", () => {
+    const template: JSONObject = { Impact: "High" };
+    const incident: JSONObject = { Ticket: "OPS-7" };
+
+    const merged: JSONObject | undefined = mergeTemplateCustomFields({
+      templateCustomFields: template,
+      customFields: incident,
+    });
+
+    expect(merged).not.toBe(template);
+    expect(merged).not.toBe(incident);
+    expect(template).toEqual({ Impact: "High" });
+    expect(incident).toEqual({ Ticket: "OPS-7" });
+  });
+
+  test("is the module's default export", () => {
+    expect(mergeTemplateCustomFieldsDefault).toBe(mergeTemplateCustomFields);
+  });
+});
+
+describe("keepValidCustomFieldValues", () => {
+  const DEFINITIONS: Array<CustomFieldDefinition> = [
+    {
+      name: "Impact",
+      customFieldType: CustomFieldType.Dropdown,
+      dropdownOptions: "Low\nMedium\nHigh",
+    },
+    { name: "Estimated Duration", customFieldType: CustomFieldType.Number },
+    { name: "Acknowledgement", customFieldType: CustomFieldType.Boolean },
+    {
+      name: "Regions",
+      customFieldType: CustomFieldType.MultiSelectDropdown,
+      dropdownOptions: "East\nWest",
+    },
+  ];
+
+  test("keeps every value that still fits its field", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: {
+          Impact: "High",
+          "Estimated Duration": "0",
+          Acknowledgement: false,
+          Regions: ["East"],
+        },
+      }),
+    ).toEqual({
+      Impact: "High",
+      "Estimated Duration": "0",
+      Acknowledgement: false,
+      Regions: ["East"],
+    });
+  });
+
+  test("drops an option removed from a dropdown since the template was saved", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: { Impact: "Critical", Regions: ["East", "North"] },
+      }),
+    ).toEqual({});
+  });
+
+  test("drops a value of the wrong kind", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: {
+          "Estimated Duration": "about an hour",
+          Acknowledgement: "maybe",
+          Impact: "Low",
+        },
+      }),
+    ).toEqual({ Impact: "Low" });
+  });
+
+  test("keeps keys with no definition, and empty values", () => {
+    expect(
+      keepValidCustomFieldValues({
+        definitions: DEFINITIONS,
+        customFields: { "Deleted Field": "x", Impact: "" },
+      }),
+    ).toEqual({ "Deleted Field": "x", Impact: "" });
+  });
+
+  test("anything but a bag gives an empty bag", () => {
+    for (const customFields of [undefined, null, "x", [1]]) {
+      expect(
+        keepValidCustomFieldValues({
+          definitions: DEFINITIONS,
+          customFields: customFields,
+        }),
+      ).toEqual({});
+    }
+  });
+});

package/Tests/Types/CustomField/CustomFieldTypeCorrespondence.test.ts

@@ -92,6 +92,54 @@ describe("CustomFieldType member set", () => {
   });
 });
 
+describe("CustomFieldType long and rich text", () => {
+  test("includes LongText and Markdown, spelled as the Detail and form types", () => {
+    /*
+     * Incident fields such as "Additional Information" need several lines,
+     * and a note-like field needs the Markdown editor. Both reuse existing
+     * render and input types, so a definition saved with either must name
+     * FieldType.LongText / FieldType.Markdown and
+     * FormFieldSchemaType.LongText / FormFieldSchemaType.Markdown by value.
+     */
+    expect(CustomFieldType.LongText).toEqual("LongText");
+    expect(CustomFieldType.Markdown).toEqual("Markdown");
+    expect(FieldType.LongText as string).toEqual(CustomFieldType.LongText);
+    expect(FieldType.Markdown as string).toEqual(CustomFieldType.Markdown);
+    expect(FormFieldSchemaType.LongText as string).toEqual(
+      CustomFieldType.LongText,
+    );
+    expect(FormFieldSchemaType.Markdown as string).toEqual(
+      CustomFieldType.Markdown,
+    );
+  });
+
+  test("keeps every member that definitions may already store", () => {
+    /*
+     * A stored definition keeps its type string forever; removing or
+     * respelling a member would make it fall through every switch.
+     */
+    expect(Object.values(CustomFieldType).sort()).toEqual(
+      [
+        "Boolean",
+        "Date",
+        "DateTime",
+        "Dropdown",
+        "LongText",
+        "Markdown",
+        "MultiSelectDropdown",
+        "Number",
+        "Text",
+      ].sort(),
+    );
+  });
+
+  test("keys equal values, so pickers built from either agree", () => {
+    for (const [key, value] of customFieldTypeEntries) {
+      expect(key).toEqual(value);
+    }
+  });
+});
+
 describe("CustomFieldType correspondence is by value, not by key", () => {
   test("Boolean reaches the form as Toggle, which is only visible by value", () => {
     /*