@oneuptime/common 12.0.7 → 12.0.9

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

@@ -0,0 +1,210 @@
+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(/run log/i);
+  });
+
+  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);
+  });
+
+  test("names the status when a run fails, so the strip is specific", () => {
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.Timeout },
+        pollCount: 1,
+      }).message,
+    ).toMatch(/timeout/i);
+
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.WorkflowCountExceeded },
+        pollCount: 1,
+      }).message,
+    ).toMatch(/workflow count exceeded/i);
+  });
+
+  test("names the status while a run is still going", () => {
+    expect(
+      decideRunWatch({
+        run: { runId: "a", status: WorkflowStatus.Scheduled },
+        pollCount: 1,
+      }).message,
+    ).toMatch(/scheduled/i);
+  });
+
+  /*
+   * A status added later must not fall through to "keep polling with nothing
+   * to say" — every one of them has to produce a line the strip can show.
+   */
+  test.each(Object.values(WorkflowStatus))(
+    "has something to say about %s",
+    (status: WorkflowStatus) => {
+      const decision: RunWatchDecision = decideRunWatch({
+        run: { runId: "a", status: status },
+        pollCount: 0,
+      });
+
+      expect(typeof decision.message).toBe("string");
+      expect(decision.message).not.toBe("");
+    },
+  );
+
+  test("stops for every status a run does not leave", () => {
+    const stillMoving: Array<WorkflowStatus> = Object.values(
+      WorkflowStatus,
+    ).filter((status: WorkflowStatus) => {
+      return decideRunWatch({
+        run: { runId: "a", status: status },
+        pollCount: 0,
+      }).shouldContinue;
+    });
+
+    expect(stillMoving).toEqual([
+      WorkflowStatus.Scheduled,
+      WorkflowStatus.Running,
+    ]);
+  });
+});

package/Tests/UI/Components/Workflow/StepTraceViewer.test.tsx

@@ -0,0 +1,256 @@
+/*
+ * A run read as the list of steps it took.
+ *
+ * The point of the viewer is that the failed step is the one you want, so most
+ * of what is worth pinning down is which rows open by themselves and what a row
+ * says before you open it.
+ */
+
+import StepTraceViewer, {
+  formatStepDuration,
+} from "../../../../UI/Components/Workflow/StepTraceViewer";
+import {
+  WorkflowStepStatus,
+  WorkflowStepTrace,
+  WorkflowStepTraceEntry,
+} from "../../../../Types/Workflow/StepTrace";
+import "@testing-library/jest-dom";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+type StepOverrides = Partial<WorkflowStepTraceEntry>;
+
+const aStep: (overrides?: StepOverrides) => WorkflowStepTraceEntry = (
+  overrides?: StepOverrides,
+): WorkflowStepTraceEntry => {
+  return {
+    componentId: "api-get-1",
+    metadataId: "api-get",
+    title: "Get from API",
+    status: WorkflowStepStatus.Success,
+    startedAt: "2024-01-01T00:00:00.000Z",
+    completedAt: "2024-01-01T00:00:01.000Z",
+    durationInMs: 1000,
+    argumentValues: {},
+    returnValues: {},
+    executedPort: "out",
+    ...overrides,
+  };
+};
+
+const renderTrace: (trace: WorkflowStepTrace) => void = (
+  trace: WorkflowStepTrace,
+): void => {
+  render(<StepTraceViewer trace={trace} />);
+};
+
+describe("formatStepDuration", () => {
+  test("keeps sub-second steps in milliseconds", () => {
+    expect(formatStepDuration(0)).toBe("0ms");
+    expect(formatStepDuration(1)).toBe("1ms");
+    expect(formatStepDuration(999)).toBe("999ms");
+  });
+
+  test("switches to seconds at a second", () => {
+    expect(formatStepDuration(1000)).toBe("1.0s");
+    expect(formatStepDuration(1500)).toBe("1.5s");
+    expect(formatStepDuration(59999)).toBe("60.0s");
+  });
+
+  test("switches to minutes at a minute", () => {
+    expect(formatStepDuration(60000)).toBe("1m 0s");
+    expect(formatStepDuration(90000)).toBe("1m 30s");
+    expect(formatStepDuration(3600000)).toBe("60m 0s");
+  });
+});
+
+describe("StepTraceViewer", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe("a run with no recorded steps", () => {
+    test("says so, and says why there might not be any", () => {
+      renderTrace({ steps: [] });
+
+      expect(screen.getByText(/no recorded steps/i)).toBeInTheDocument();
+      expect(screen.getByText(/before step recording/i)).toBeInTheDocument();
+    });
+
+    test("survives a trace that is missing its steps entirely", () => {
+      render(
+        <StepTraceViewer trace={undefined as unknown as WorkflowStepTrace} />,
+      );
+
+      expect(screen.getByText(/no recorded steps/i)).toBeInTheDocument();
+    });
+  });
+
+  describe("a step's row", () => {
+    test("names the step and the component it came from", () => {
+      renderTrace({
+        steps: [aStep({ title: "Post to Slack", componentId: "slack-1" })],
+      });
+
+      expect(screen.getByText("Post to Slack")).toBeInTheDocument();
+      expect(screen.getByText("slack-1")).toBeInTheDocument();
+    });
+
+    test("says how long it took", () => {
+      renderTrace({ steps: [aStep({ durationInMs: 2500 })] });
+
+      expect(screen.getByText("2.5s")).toBeInTheDocument();
+    });
+
+    test("says which way the run went afterwards", () => {
+      renderTrace({ steps: [aStep({ executedPort: "success" })] });
+
+      expect(screen.getByText("→ success")).toBeInTheDocument();
+    });
+
+    test("says nothing about a port when the step ended the run", () => {
+      renderTrace({ steps: [aStep({ executedPort: null })] });
+
+      expect(screen.queryByText(/→/)).not.toBeInTheDocument();
+    });
+
+    test("numbers the steps in the order they ran", () => {
+      renderTrace({
+        steps: [
+          aStep({ title: "First", componentId: "one" }),
+          aStep({ title: "Second", componentId: "two" }),
+          aStep({ title: "Third", componentId: "three" }),
+        ],
+      });
+
+      expect(screen.getByText("1")).toBeInTheDocument();
+      expect(screen.getByText("2")).toBeInTheDocument();
+      expect(screen.getByText("3")).toBeInTheDocument();
+    });
+  });
+
+  describe("opening a step", () => {
+    test("a step that worked stays shut until asked", () => {
+      renderTrace({
+        steps: [aStep({ argumentValues: { url: "https://example.com" } })],
+      });
+
+      expect(screen.queryByText("Received")).not.toBeInTheDocument();
+
+      fireEvent.click(screen.getByRole("button", { expanded: false }));
+
+      expect(screen.getByText("Received")).toBeInTheDocument();
+      expect(screen.getByText("Returned")).toBeInTheDocument();
+      expect(screen.getByText("https://example.com")).toBeInTheDocument();
+    });
+
+    test("closes again", () => {
+      renderTrace({ steps: [aStep()] });
+
+      fireEvent.click(screen.getByRole("button", { expanded: false }));
+      fireEvent.click(screen.getByRole("button", { expanded: true }));
+
+      expect(screen.queryByText("Received")).not.toBeInTheDocument();
+    });
+
+    /*
+     * The step that broke the run is the reason anyone opened this. It should
+     * not need a click.
+     */
+    test("a step that failed is open already, with its error", () => {
+      renderTrace({
+        steps: [
+          aStep({
+            status: WorkflowStepStatus.Error,
+            errorMessage: "Request timed out after 30s",
+          }),
+        ],
+      });
+
+      expect(
+        screen.getByText("Request timed out after 30s"),
+      ).toBeInTheDocument();
+      expect(screen.getByText("Received")).toBeInTheDocument();
+    });
+
+    test("only the failed step opens", () => {
+      renderTrace({
+        steps: [
+          aStep({ title: "Worked", componentId: "ok-1" }),
+          aStep({
+            title: "Broke",
+            componentId: "bad-1",
+            status: WorkflowStepStatus.Error,
+            errorMessage: "Nope",
+          }),
+        ],
+      });
+
+      expect(screen.getByText("Nope")).toBeInTheDocument();
+      expect(screen.getAllByText("Received")).toHaveLength(1);
+    });
+  });
+
+  describe("the values a step received and returned", () => {
+    test("says None rather than showing an empty list", () => {
+      renderTrace({ steps: [aStep({ argumentValues: {}, returnValues: {} })] });
+
+      fireEvent.click(screen.getByRole("button", { expanded: false }));
+
+      expect(screen.getAllByText("None")).toHaveLength(2);
+    });
+
+    test("shows a string as it is", () => {
+      renderTrace({
+        steps: [aStep({ returnValues: { body: "hello there" } })],
+      });
+
+      fireEvent.click(screen.getByRole("button", { expanded: false }));
+
+      expect(screen.getByText("body")).toBeInTheDocument();
+      expect(screen.getByText("hello there")).toBeInTheDocument();
+    });
+
+    test("serializes anything structured", () => {
+      renderTrace({
+        steps: [
+          aStep({
+            returnValues: { data: { id: 4, ok: true } as never },
+          }),
+        ],
+      });
+
+      fireEvent.click(screen.getByRole("button", { expanded: false }));
+
+      const rendered: HTMLElement | undefined = Array.from(
+        document.querySelectorAll("dd"),
+      ).find((element: Element) => {
+        return (
+          element.textContent === JSON.stringify({ id: 4, ok: true }, null, 2)
+        );
+      }) as HTMLElement | undefined;
+
+      expect(rendered).toBeDefined();
+    });
+  });
+
+  describe("a run too long to keep whole", () => {
+    test("says how much of it survived rather than looking complete", () => {
+      renderTrace({
+        steps: [aStep(), aStep({ componentId: "api-get-2" })],
+        truncated: true,
+      });
+
+      expect(
+        screen.getByText("Only the last 2 steps of this run were kept."),
+      ).toBeInTheDocument();
+    });
+
+    test("says nothing when the whole run is there", () => {
+      renderTrace({ steps: [aStep()] });
+
+      expect(screen.queryByText(/Only the last/)).not.toBeInTheDocument();
+    });
+  });
+});