@oneuptime/common 12.0.10 → 12.0.11

package/Tests/Types/Billing/PayAsYouGoPricing.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH,
+  PRICING_PAGE_URL,
+  SESSION_REPLAY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_IN_USD_PER_GB,
+  TELEMETRY_PRICE_RETENTION_IN_DAYS,
+  formatPriceInUSD,
+} from "../../../Types/Billing/PayAsYouGoPricing";
+
+/*
+ * These constants are quoted to users, verbatim, on the telemetry ingestion
+ * key and create monitor pages. They are pinned here because changing one
+ * silently changes what the product promises a customer - a change to any of
+ * them has to be deliberate, and has to be made on the pricing page too.
+ */
+
+describe("PayAsYouGoPricing", () => {
+  describe("rates", () => {
+    it("charges $0.10 per GB of telemetry, quoted for 15 day retention", () => {
+      expect(TELEMETRY_PRICE_IN_USD_PER_GB).toBe(0.1);
+      expect(TELEMETRY_PRICE_RETENTION_IN_DAYS).toBe(15);
+    });
+
+    it("charges $2 per GB for session replay, on the same 15 day window", () => {
+      expect(SESSION_REPLAY_PRICE_IN_USD_PER_GB).toBe(2);
+    });
+
+    it("charges $1 per active monitor per month", () => {
+      expect(ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH).toBe(1);
+    });
+
+    it("points at the public pricing page", () => {
+      expect(PRICING_PAGE_URL).toBe("https://oneuptime.com/pricing");
+    });
+  });
+
+  describe("formatPriceInUSD", () => {
+    it("writes a whole number of dollars without cents, like the pricing page", () => {
+      expect(formatPriceInUSD(1)).toBe("$1");
+      expect(formatPriceInUSD(22)).toBe("$22");
+      expect(formatPriceInUSD(0)).toBe("$0");
+    });
+
+    it("writes a fractional amount with two decimal places", () => {
+      expect(formatPriceInUSD(0.1)).toBe("$0.10");
+      expect(formatPriceInUSD(1.5)).toBe("$1.50");
+      expect(formatPriceInUSD(2.05)).toBe("$2.05");
+    });
+
+    it("rounds to cents rather than spilling extra digits into the copy", () => {
+      expect(formatPriceInUSD(0.125)).toBe("$0.13");
+      expect(formatPriceInUSD(0.006)).toBe("$0.01");
+    });
+
+    it("renders the advertised rates exactly as the pricing page writes them", () => {
+      expect(formatPriceInUSD(TELEMETRY_PRICE_IN_USD_PER_GB)).toBe("$0.10");
+      expect(formatPriceInUSD(SESSION_REPLAY_PRICE_IN_USD_PER_GB)).toBe("$2");
+      expect(formatPriceInUSD(ACTIVE_MONITOR_PRICE_IN_USD_PER_MONTH)).toBe(
+        "$1",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,107 @@
+import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
+import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * CustomFieldsDetail does not translate a definition's `customFieldType` into a
+ * render type - it hands the raw string to a Detail field and to a form field
+ * as their `fieldType`, through an `as any` that erases the enum on the way.
+ * Nothing in the compiler is watching that seam, so a member added here without
+ * a same-VALUE member in FieldType and FormFieldSchemaType type-checks, builds,
+ * ships, and only then shows itself: the Detail column falls off the end of the
+ * render switch and paints an empty cell, and the form falls off the end of the
+ * input switch and paints a control the user cannot type into. The field looks
+ * present and is silently unusable, which is the worst shape a regression can
+ * take because nothing throws and nothing logs.
+ *
+ * These are value-set comparisons rather than key comparisons on purpose. The
+ * three enums are free to spell a member however reads best on their own side -
+ * `Boolean` reaches the form as `FormFieldSchemaType.Toggle`, which is written
+ * `Toggle = "Boolean"` for exactly this reason - and only the value crosses the
+ * seam. A key-based check would both miss real breakage and reject that legal
+ * spelling.
+ */
+
+const customFieldTypeEntries: Array<[string, string]> = Object.entries(
+  CustomFieldType,
+) as Array<[string, string]>;
+
+const fieldTypeValues: Set<string> = new Set<string>(
+  Object.values(FieldType) as Array<string>,
+);
+
+const formFieldSchemaTypeValues: Set<string> = new Set<string>(
+  Object.values(FormFieldSchemaType) as Array<string>,
+);
+
+describe("CustomFieldType corresponds to FieldType", () => {
+  test.each(customFieldTypeEntries)(
+    "CustomFieldType.%s is a FieldType value",
+    (_key: string, value: string) => {
+      expect(fieldTypeValues.has(value)).toBe(true);
+    },
+  );
+});
+
+describe("CustomFieldType corresponds to FormFieldSchemaType", () => {
+  test.each(customFieldTypeEntries)(
+    "CustomFieldType.%s is a FormFieldSchemaType value",
+    (_key: string, value: string) => {
+      expect(formFieldSchemaTypeValues.has(value)).toBe(true);
+    },
+  );
+});
+
+describe("CustomFieldType member set", () => {
+  test("has at least one member so the correspondence loops cannot pass vacuously", () => {
+    /*
+     * The two blocks above are generated from this enum. If it were ever
+     * emptied - a bad merge, a barrel file re-export that resolves to {} - the
+     * per-member assertions would simply stop existing and the suite would go
+     * green while guarding nothing.
+     */
+    expect(customFieldTypeEntries.length).toBeGreaterThan(0);
+  });
+
+  test("has no duplicate values", () => {
+    /*
+     * Two keys sharing a value collapse at runtime: the second one wins every
+     * lookup, and a definition saved under the first key renders as the second
+     * one's type. It also makes the loops above lie, because a duplicate is
+     * checked twice and the shadowed member is never exercised on its own.
+     */
+    const values: Array<string> = customFieldTypeEntries.map(
+      ([, value]: [string, string]) => {
+        return value;
+      },
+    );
+
+    expect(new Set<string>(values).size).toBe(values.length);
+  });
+
+  test("includes Date and DateTime", () => {
+    /*
+     * The date members are what the jsonb range filters and the ISO-8601
+     * storage format exist for. Losing them is a silent feature removal - old
+     * definitions keep their stored `customFieldType` string in the database
+     * and would then fall through every switch that reads this enum.
+     */
+    expect(CustomFieldType.Date).toEqual("Date");
+    expect(CustomFieldType.DateTime).toEqual("DateTime");
+  });
+});
+
+describe("CustomFieldType correspondence is by value, not by key", () => {
+  test("Boolean reaches the form as Toggle, which is only visible by value", () => {
+    /*
+     * This is the case that proves the checks above have to compare values.
+     * FormFieldSchemaType has no member named `Boolean`; it names the same
+     * value `Toggle`. A correspondence test written against key names would
+     * fail here on code that works perfectly, and would then be "fixed" by
+     * relaxing it into something that no longer catches a missing member.
+     */
+    expect(Object.keys(FormFieldSchemaType)).not.toContain("Boolean");
+    expect(FormFieldSchemaType.Toggle).toEqual(CustomFieldType.Boolean);
+  });
+});

package/Tests/Types/Monitor/MonitorType.test.ts

@@ -253,6 +253,68 @@ describe("MonitorTypeHelper", () => {
     });
   });
 
+  /*
+   * The dashboard tells Free plan users which monitors cost money before they
+   * create one, and gates the create button on acknowledging it. That warning
+   * is only honest while this predicate agrees with what the server actually
+   * meters - ActiveMonitoringMeteredPlan counts every monitor whose type is
+   * not Manual.
+   */
+  describe("isBilledAsActiveMonitor", () => {
+    test("Manual monitors are free", () => {
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Manual),
+      ).toBe(false);
+    });
+
+    test("every other monitor type is billed", () => {
+      const billed: Array<MonitorType> = Object.values(MonitorType).filter(
+        (monitorType: MonitorType) => {
+          return monitorType !== MonitorType.Manual;
+        },
+      );
+
+      expect(billed.length).toBeGreaterThan(0);
+
+      for (const monitorType of billed) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          true,
+        );
+      }
+    });
+
+    test("telemetry monitors are billed as active monitors too, on top of their ingest", () => {
+      expect(MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Logs)).toBe(
+        true,
+      );
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Metrics),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.isBilledAsActiveMonitor(MonitorType.Traces),
+      ).toBe(true);
+    });
+
+    test("agrees exactly with getActiveMonitorTypes", () => {
+      const active: Array<MonitorType> =
+        MonitorTypeHelper.getActiveMonitorTypes();
+
+      for (const monitorType of Object.values(MonitorType)) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          active.includes(monitorType),
+        );
+      }
+    });
+
+    test("is the exact inverse of isManualMonitor", () => {
+      for (const monitorType of Object.values(MonitorType)) {
+        expect(MonitorTypeHelper.isBilledAsActiveMonitor(monitorType)).toBe(
+          !MonitorTypeHelper.isManualMonitor(monitorType),
+        );
+      }
+    });
+  });
+
   describe("doesMonitorTypeHaveGraphs", () => {
     test("returns true for graphable types and false otherwise", () => {
       expect(

package/Tests/UI/Components/Charts/ChartXAxisDataKey.test.tsx

@@ -0,0 +1,256 @@
+import "@testing-library/jest-dom";
+import { cleanup, render } from "@testing-library/react";
+import React from "react";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * ResponsiveContainer measures its parent, which is always 0x0 in jsdom, so
+ * the chart renders nothing without a fixed size. Same shim as
+ * AxisTickColor.test.tsx — anything that asserts on rendered GEOMETRY needs
+ * it, because a 0x0 chart draws no marks either and would make every one of
+ * these assertions pass for the wrong reason.
+ */
+jest.mock("recharts", () => {
+  const actual: Record<string, any> = jest.requireActual("recharts");
+  return {
+    ...actual,
+    ResponsiveContainer: ({ children }: { children: React.ReactElement }) => {
+      return React.cloneElement(children, { width: 600, height: 300 });
+    },
+  };
+});
+
+import AreaChartElement from "../../../../UI/Components/Charts/Area/AreaChart";
+import BarChartElement from "../../../../UI/Components/Charts/Bar/BarChart";
+import LineChartElement from "../../../../UI/Components/Charts/Line/LineChart";
+import { CHART_DATA_POINT_X_AXIS_KEY } from "../../../../UI/Components/Charts/ChartLibrary/Types/ChartDataPoint";
+import ChartCurve from "../../../../UI/Components/Charts/Types/ChartCurve";
+import DataPoint from "../../../../UI/Components/Charts/Types/DataPoint";
+import SeriesPoint from "../../../../UI/Components/Charts/Types/SeriesPoints";
+import {
+  XAxis as ChartXAxis,
+  XAxisAggregateType,
+} from "../../../../UI/Components/Charts/Types/XAxis/XAxis";
+import XAxisType from "../../../../UI/Components/Charts/Types/XAxis/XAxisType";
+import YAxis, {
+  YAxisPrecision,
+} from "../../../../UI/Components/Charts/Types/YAxis/YAxis";
+import YAxisType from "../../../../UI/Components/Charts/Types/YAxis/YAxisType";
+
+/*
+ * The three chart wrappers hand recharts a FIXED x-axis dataKey, while the
+ * rows they hand it are built by DataPointUtil. Those two used to agree only
+ * by convention: the util keyed each row by the caller's `xAxis.legend`, and
+ * every caller but one happened to pass the literal "Time".
+ *
+ * The one that did not — the SLO dashboard widget, which passed "" — got a
+ * chart with axes, grid and tooltip but no line: recharts looked up "Time" on
+ * every row, found nothing, and drew no path. Nothing failed, nothing logged;
+ * the widget just rendered an empty frame on public and private dashboards
+ * alike.
+ *
+ * These tests hold the axis key on both sides of that seam: whatever legend a
+ * caller passes, the marks get drawn.
+ */
+
+const START: Date = new Date("2026-08-10T00:00:00.000Z");
+const END: Date = new Date("2026-08-10T01:00:00.000Z");
+
+/* An hour window buckets at one minute, so these land on distinct buckets. */
+type BuildPointsFunction = () => Array<DataPoint>;
+
+const buildPoints: BuildPointsFunction = (): Array<DataPoint> => {
+  const points: Array<DataPoint> = [];
+
+  for (let index: number = 0; index < 10; index++) {
+    points.push({
+      x: new Date(START.getTime() + index * 60 * 1000),
+      y: 90 + index,
+    });
+  }
+
+  return points;
+};
+
+type BuildXAxisFunction = (legend: string) => ChartXAxis;
+
+const buildXAxis: BuildXAxisFunction = (legend: string): ChartXAxis => {
+  return {
+    legend: legend,
+    options: {
+      type: XAxisType.Time,
+      min: START,
+      max: END,
+      aggregateType: XAxisAggregateType.Average,
+    },
+  };
+};
+
+const Y_AXIS: YAxis = {
+  legend: "%",
+  options: {
+    type: YAxisType.Number,
+    min: "auto",
+    max: 100,
+    precision: YAxisPrecision.TwoDecimals,
+    formatter: (value: number): string => {
+      return `${value}%`;
+    },
+  },
+};
+
+const SERIES_NAME: string = "SLI";
+
+type BuildSeriesFunction = () => Array<SeriesPoint>;
+
+const buildSeries: BuildSeriesFunction = (): Array<SeriesPoint> => {
+  return [{ seriesName: SERIES_NAME, data: buildPoints() }];
+};
+
+/*
+ * Legends worth covering: the canonical one every other caller passes, the
+ * empty string the SLO widget passed (the reported bug), and an arbitrary
+ * label, which is what a future caller is most likely to reach for.
+ */
+const LEGENDS: Array<[string, string]> = [
+  ['the canonical "Time"', "Time"],
+  ["an empty legend", ""],
+  ["an arbitrary legend", "Timestamp"],
+  ["a legend with markup-ish characters", "Time (UTC) <>"],
+];
+
+interface ChartUnderTest {
+  name: string;
+  /** CSS selector for the SVG geometry this chart type draws per series. */
+  markSelector: string;
+  render: (xAxis: ChartXAxis) => React.ReactElement;
+}
+
+const CHARTS: Array<ChartUnderTest> = [
+  {
+    name: "LineChart",
+    markSelector: "path.recharts-line-curve",
+    render: (xAxis: ChartXAxis): React.ReactElement => {
+      return (
+        <LineChartElement
+          data={buildSeries()}
+          xAxis={xAxis}
+          yAxis={Y_AXIS}
+          curve={ChartCurve.MONOTONE}
+          heightInPx={300}
+          showLegend={false}
+          sync={false}
+          syncid="x-axis-key-test"
+        />
+      );
+    },
+  },
+  {
+    name: "AreaChart",
+    markSelector: "path.recharts-area-area",
+    render: (xAxis: ChartXAxis): React.ReactElement => {
+      return (
+        <AreaChartElement
+          data={buildSeries()}
+          xAxis={xAxis}
+          yAxis={Y_AXIS}
+          curve={ChartCurve.MONOTONE}
+          heightInPx={300}
+          showLegend={false}
+          sync={false}
+          syncid="x-axis-key-test"
+        />
+      );
+    },
+  },
+  {
+    /*
+     * Bars are drawn through a custom `shape` renderer, so the mark is a bare
+     * <path> under recharts' own rectangle group rather than a classed one.
+     */
+    name: "BarChart",
+    markSelector: "g.recharts-bar-rectangle path",
+    render: (xAxis: ChartXAxis): React.ReactElement => {
+      return (
+        <BarChartElement
+          data={buildSeries()}
+          xAxis={xAxis}
+          yAxis={Y_AXIS}
+          heightInPx={300}
+          showLegend={false}
+          sync={false}
+          syncid="x-axis-key-test"
+        />
+      );
+    },
+  },
+];
+
+afterEach((): void => {
+  cleanup();
+});
+
+describe("Chart x-axis data key", () => {
+  test("the canonical key is the literal recharts reads", (): void => {
+    /*
+     * Pinned, not derived. The wrappers and DataPointUtil both import this
+     * constant, so a rename would keep them agreeing with each other while
+     * silently changing the shape handed to recharts.
+     */
+    expect(CHART_DATA_POINT_X_AXIS_KEY).toBe("Time");
+  });
+
+  for (const chart of CHARTS) {
+    describe(chart.name, () => {
+      test.each(LEGENDS)(
+        `draws its series with %s`,
+        (_label: string, legend: string): void => {
+          const { container } = render(chart.render(buildXAxis(legend)));
+
+          const marks: Array<Element> = Array.from(
+            container.querySelectorAll(chart.markSelector),
+          );
+
+          expect(marks.length).toBeGreaterThan(0);
+
+          /*
+           * Present-but-empty geometry is the exact failure mode here: a
+           * <path> with no `d` renders nothing at all, so the element count
+           * alone would not have caught the bug.
+           */
+          for (const mark of marks) {
+            expect(mark.getAttribute("d")).toBeTruthy();
+          }
+        },
+      );
+
+      test("draws the same geometry whatever the legend says", (): void => {
+        const canonical: RenderResultContainer = render(
+          chart.render(buildXAxis("Time")),
+        );
+        const canonicalPaths: Array<string | null> = Array.from(
+          canonical.container.querySelectorAll(chart.markSelector),
+        ).map((element: Element) => {
+          return element.getAttribute("d");
+        });
+
+        cleanup();
+
+        const other: RenderResultContainer = render(
+          chart.render(buildXAxis("")),
+        );
+        const otherPaths: Array<string | null> = Array.from(
+          other.container.querySelectorAll(chart.markSelector),
+        ).map((element: Element) => {
+          return element.getAttribute("d");
+        });
+
+        expect(otherPaths).toEqual(canonicalPaths);
+      });
+    });
+  }
+});
+
+interface RenderResultContainer {
+  container: HTMLElement;
+}