@oneuptime/common 12.0.6 → 12.0.8

package/Tests/UI/Components/Workflow/RunStatusWatcher.test.ts

@@ -0,0 +1,152 @@
+import {
+  MAX_RUN_WATCH_POLLS,
+  RunWatchDecision,
+  decideRunWatch,
+  isFailedRunStatus,
+  isTerminalRunStatus,
+} from "../../../../UI/Components/Workflow/RunStatusWatcher";
+import WorkflowStatus from "../../../../Types/Workflow/WorkflowStatus";
+import { describe, expect, test } from "@jest/globals";
+
+describe("isTerminalRunStatus", () => {
+  test("settles on the statuses a run never leaves", () => {
+    expect(isTerminalRunStatus(WorkflowStatus.Success)).toBe(true);
+    expect(isTerminalRunStatus(WorkflowStatus.Error)).toBe(true);
+    expect(isTerminalRunStatus(WorkflowStatus.Timeout)).toBe(true);
+    expect(isTerminalRunStatus(WorkflowStatus.WorkflowCountExceeded)).toBe(
+      true,
+    );
+  });
+
+  test("keeps watching while a run is still moving", () => {
+    expect(isTerminalRunStatus(WorkflowStatus.Scheduled)).toBe(false);
+    expect(isTerminalRunStatus(WorkflowStatus.Running)).toBe(false);
+  });
+
+  /*
+   * Waiting is a Sleep step parking the run. It carries on afterwards, so it
+   * is not an ending — but it is also not worth watching, which decideRunWatch
+   * handles separately.
+   */
+  test("does not treat Waiting as an ending", () => {
+    expect(isTerminalRunStatus(WorkflowStatus.Waiting)).toBe(false);
+  });
+
+  test("handles nothing at all", () => {
+    expect(isTerminalRunStatus(null)).toBe(false);
+    expect(isTerminalRunStatus(undefined)).toBe(false);
+  });
+});
+
+describe("isFailedRunStatus", () => {
+  test("is true only for the unhappy endings", () => {
+    expect(isFailedRunStatus(WorkflowStatus.Error)).toBe(true);
+    expect(isFailedRunStatus(WorkflowStatus.Timeout)).toBe(true);
+    expect(isFailedRunStatus(WorkflowStatus.WorkflowCountExceeded)).toBe(true);
+
+    expect(isFailedRunStatus(WorkflowStatus.Success)).toBe(false);
+    expect(isFailedRunStatus(WorkflowStatus.Running)).toBe(false);
+    expect(isFailedRunStatus(WorkflowStatus.Waiting)).toBe(false);
+    expect(isFailedRunStatus(null)).toBe(false);
+    expect(isFailedRunStatus(undefined)).toBe(false);
+  });
+});
+
+describe("decideRunWatch", () => {
+  test("keeps waiting while the run has not appeared yet", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: null,
+      pollCount: 0,
+    });
+
+    expect(decision.shouldContinue).toBe(true);
+    expect(decision.message).toMatch(/Starting/i);
+  });
+
+  test("keeps watching a running run and says so", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: { runId: "a", status: WorkflowStatus.Running },
+      pollCount: 1,
+    });
+
+    expect(decision.shouldContinue).toBe(true);
+    expect(decision.message).toMatch(/running/i);
+  });
+
+  test("keeps watching a scheduled run", () => {
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.Scheduled },
+        pollCount: 1,
+      }).shouldContinue,
+    ).toBe(true);
+  });
+
+  test("stops on success with a plain statement", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: { runId: "a", status: WorkflowStatus.Success },
+      pollCount: 3,
+    });
+
+    expect(decision.shouldContinue).toBe(false);
+    expect(decision.message).toMatch(/finished successfully/i);
+  });
+
+  test("stops on failure and points at the logs", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: { runId: "a", status: WorkflowStatus.Error },
+      pollCount: 3,
+    });
+
+    expect(decision.shouldContinue).toBe(false);
+    expect(decision.message).toMatch(/Logs tab/);
+  });
+
+  test("stops on timeout", () => {
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.Timeout },
+        pollCount: 3,
+      }).shouldContinue,
+    ).toBe(false);
+  });
+
+  test("stops following a run that went to sleep, and explains why", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: { runId: "a", status: WorkflowStatus.Waiting },
+      pollCount: 3,
+    });
+
+    expect(decision.shouldContinue).toBe(false);
+    expect(decision.message).toMatch(/sleeping/i);
+    expect(decision.message).toMatch(/carry on/i);
+  });
+
+  test("gives up rather than polling forever", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: { runId: "a", status: WorkflowStatus.Running },
+      pollCount: MAX_RUN_WATCH_POLLS,
+    });
+
+    expect(decision.shouldContinue).toBe(false);
+    expect(decision.message).toMatch(/taking a while/i);
+  });
+
+  test("gives up even when the run never appeared", () => {
+    const decision: RunWatchDecision = decideRunWatch({
+      run: null,
+      pollCount: MAX_RUN_WATCH_POLLS,
+    });
+
+    expect(decision.shouldContinue).toBe(false);
+  });
+
+  test("polls right up to the limit but not past it", () => {
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.Running },
+        pollCount: MAX_RUN_WATCH_POLLS - 1,
+      }).shouldContinue,
+    ).toBe(true);
+  });
+});

package/Tests/UI/Components/Workflow/Utils.test.ts

@@ -0,0 +1,192 @@
+/*
+ * Utils.ts imports the whole database-model registry for
+ * loadComponentsAndCategories, which nothing here exercises. Stubbing it keeps
+ * this suite from type-checking several hundred model files to test two pure
+ * functions.
+ */
+jest.mock("../../../../Models/DatabaseModels/Index", () => {
+  return {
+    __esModule: true,
+    default: [],
+  };
+});
+
+import {
+  componentInputTypeToFormFieldType,
+  parseStringDictionaryValue,
+} from "../../../../UI/Components/Workflow/Utils";
+import FormFieldSchemaType from "../../../../UI/Components/Forms/Types/FormFieldSchemaType";
+import { JSONObject } from "../../../../Types/JSON";
+import { ComponentInputType } from "../../../../Types/Workflow/Component";
+import { describe, expect, test } from "@jest/globals";
+
+describe("parseStringDictionaryValue", () => {
+  test("treats an unset value as an empty dictionary", () => {
+    expect(parseStringDictionaryValue(undefined)).toEqual({});
+    expect(parseStringDictionaryValue(null)).toEqual({});
+    expect(parseStringDictionaryValue("")).toEqual({});
+    expect(parseStringDictionaryValue("   ")).toEqual({});
+  });
+
+  test("parses the JSON string shape every existing workflow stores", () => {
+    expect(
+      parseStringDictionaryValue('{"Authorization": "Bearer abc"}'),
+    ).toEqual({
+      Authorization: "Bearer abc",
+    });
+  });
+
+  test("accepts JSON5, which is what the components themselves accept", () => {
+    expect(parseStringDictionaryValue("{header1: 'value1'}")).toEqual({
+      header1: "value1",
+    });
+    expect(parseStringDictionaryValue('{"a": "b",}')).toEqual({ a: "b" });
+  });
+
+  test("passes an already-parsed object straight through", () => {
+    const value: JSONObject = { "X-Key": "v" };
+
+    expect(parseStringDictionaryValue(value)).toEqual({ "X-Key": "v" });
+  });
+
+  test("keeps numbers and booleans, which the row editor can represent", () => {
+    expect(parseStringDictionaryValue('{"n": 1, "b": true}')).toEqual({
+      n: 1,
+      b: true,
+    });
+  });
+
+  test("declines a whole-field template, which is not JSON as written", () => {
+    expect(
+      parseStringDictionaryValue(
+        "{{local.components.api-get-1.returnValues.response-headers}}",
+      ),
+    ).toBeNull();
+  });
+
+  test("declines text that does not parse, so it stays visible and fixable", () => {
+    expect(parseStringDictionaryValue('{"a": ')).toBeNull();
+    expect(parseStringDictionaryValue("not json")).toBeNull();
+  });
+
+  test("declines nested values the row editor would silently discard", () => {
+    expect(parseStringDictionaryValue('{"a": {"b": 1}}')).toBeNull();
+    expect(parseStringDictionaryValue('{"a": ["b"]}')).toBeNull();
+    expect(parseStringDictionaryValue('{"a": null}')).toBeNull();
+  });
+
+  test("declines arrays and scalars, which are not dictionaries", () => {
+    expect(parseStringDictionaryValue("[1, 2]")).toBeNull();
+    expect(parseStringDictionaryValue("42")).toBeNull();
+  });
+
+  test("keeps a value containing a template inside a string", () => {
+    expect(
+      parseStringDictionaryValue(
+        '{"Authorization": "Bearer {{local.variables.token}}"}',
+      ),
+    ).toEqual({
+      Authorization: "Bearer {{local.variables.token}}",
+    });
+  });
+});
+
+describe("componentInputTypeToFormFieldType — StringDictionary", () => {
+  test("uses the key/value editor for a value it can represent", () => {
+    expect(
+      componentInputTypeToFormFieldType(
+        ComponentInputType.StringDictionary,
+        '{"a": "b"}',
+      ).fieldType,
+    ).toBe(FormFieldSchemaType.Dictionary);
+  });
+
+  test("uses the key/value editor for an unset value", () => {
+    expect(
+      componentInputTypeToFormFieldType(
+        ComponentInputType.StringDictionary,
+        null,
+      ).fieldType,
+    ).toBe(FormFieldSchemaType.Dictionary);
+  });
+
+  test("falls back to the JSON editor for a whole-field template", () => {
+    expect(
+      componentInputTypeToFormFieldType(
+        ComponentInputType.StringDictionary,
+        "{{local.components.a.returnValues.response-headers}}",
+      ).fieldType,
+    ).toBe(FormFieldSchemaType.JSON);
+  });
+
+  test("falls back to the JSON editor for a value that does not parse", () => {
+    expect(
+      componentInputTypeToFormFieldType(
+        ComponentInputType.StringDictionary,
+        '{"a": ',
+      ).fieldType,
+    ).toBe(FormFieldSchemaType.JSON);
+  });
+
+  test("agrees with parseStringDictionaryValue for every case", () => {
+    const samples: Array<unknown> = [
+      undefined,
+      null,
+      "",
+      '{"a":"b"}',
+      "{a:'b'}",
+      "{{local.variables.x}}",
+      '{"a":{"b":1}}',
+      "[1,2]",
+      "garbage",
+      { a: "b" },
+    ];
+
+    for (const sample of samples) {
+      const expected: FormFieldSchemaType =
+        parseStringDictionaryValue(sample) === null
+          ? FormFieldSchemaType.JSON
+          : FormFieldSchemaType.Dictionary;
+
+      expect(
+        componentInputTypeToFormFieldType(
+          ComponentInputType.StringDictionary,
+          sample,
+        ).fieldType,
+      ).toBe(expected);
+    }
+  });
+});
+
+describe("componentInputTypeToFormFieldType — unchanged mappings", () => {
+  test("JSON-document types still use the code editor", () => {
+    const jsonTypes: Array<ComponentInputType> = [
+      ComponentInputType.JSON,
+      ComponentInputType.JSONArray,
+      ComponentInputType.Query,
+      ComponentInputType.Select,
+      ComponentInputType.BaseModel,
+      ComponentInputType.BaseModelArray,
+    ];
+
+    for (const type of jsonTypes) {
+      expect(componentInputTypeToFormFieldType(type, null).fieldType).toBe(
+        FormFieldSchemaType.JSON,
+      );
+    }
+  });
+
+  test("simple types are untouched", () => {
+    expect(
+      componentInputTypeToFormFieldType(ComponentInputType.Email, null)
+        .fieldType,
+    ).toBe(FormFieldSchemaType.Email);
+    expect(
+      componentInputTypeToFormFieldType(ComponentInputType.URL, null).fieldType,
+    ).toBe(FormFieldSchemaType.URL);
+    expect(
+      componentInputTypeToFormFieldType(ComponentInputType.Boolean, null)
+        .fieldType,
+    ).toBe(FormFieldSchemaType.Toggle);
+  });
+});