@oneuptime/common 14.0.10 → 14.0.11

package/Tests/UI/Components/MonacoRuntime.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, test } from "@jest/globals";
-import fs from "fs";
-import path from "path";
-
-/*
- * The build copies monaco-editor's min/vs next to each frontend bundle and
- * MonacoLoader points @monaco-editor/loader at it, so the version we install is
- * the version that actually runs in the browser.
- *
- * The loader resolves init() with whatever the AMD module `vs/editor/editor.main`
- * exports, and that shape is not stable across Monaco releases. 0.53 and 0.54
- * nest the API under `exports.m`; against a loader that does not unwrap that,
- * `monaco.editor` comes back undefined and every editor throws
- * "Cannot read properties of undefined (reading 'getModel')" instead of
- * mounting - with the assets all serving 200, so nothing else looks wrong.
- *
- * @monaco-editor/loader learned to unwrap it in 1.7.0. These tests fail if the
- * two are ever moved into a combination that cannot work.
- */
-
-// [from, to) - the Monaco releases whose AMD module nests the API under `exports.m`.
-const NESTED_API_RANGE: { from: string; to: string } = {
-  from: "0.53.0",
-  to: "0.55.0",
-};
-
-// The first @monaco-editor/loader that unwraps `exports.m`.
-const LOADER_UNWRAPS_FROM: string = "1.7.0";
-
-type ReadVersion = (packageName: string) => string;
-
-const readVersion: ReadVersion = (packageName: string): string => {
-  return JSON.parse(
-    fs.readFileSync(require.resolve(`${packageName}/package.json`), "utf8"),
-  ).version;
-};
-
-type Compare = (a: string, b: string) => number;
-
-const compare: Compare = (a: string, b: string): number => {
-  const left: Array<number> = a.split(".").map(Number);
-  const right: Array<number> = b.split(".").map(Number);
-
-  for (let i: number = 0; i < 3; i++) {
-    const difference: number = (left[i] || 0) - (right[i] || 0);
-
-    if (difference !== 0) {
-      return difference;
-    }
-  }
-
-  return 0;
-};
-
-describe("Monaco runtime", () => {
-  test("does not pair a nested-API Monaco with a loader that cannot unwrap it", () => {
-    const monacoVersion: string = readVersion("monaco-editor");
-    const loaderVersion: string = readVersion("@monaco-editor/loader");
-
-    const nestsApi: boolean =
-      compare(monacoVersion, NESTED_API_RANGE.from) >= 0 &&
-      compare(monacoVersion, NESTED_API_RANGE.to) < 0;
-
-    if (!nestsApi) {
-      return;
-    }
-
-    expect({
-      monacoVersion,
-      loaderVersion,
-      unwrapsNestedApi: compare(loaderVersion, LOADER_UNWRAPS_FROM) >= 0,
-    }).toEqual({
-      monacoVersion,
-      loaderVersion,
-      unwrapsNestedApi: true,
-    });
-  });
-
-  test("ships the files the loader asks for by path", () => {
-    const monacoRoot: string = path.dirname(
-      require.resolve("monaco-editor/package.json"),
-    );
-
-    /*
-     * The loader builds a script tag for `${paths.vs}/loader.js` and then
-     * require()s `vs/editor/editor.main`. Everything else Monaco pulls in is
-     * relative to those two, so a missing one is the difference between a
-     * working editor and a silent 404 on an air-gapped install.
-     */
-    for (const asset of ["loader.js", "editor/editor.main.js"]) {
-      expect(fs.existsSync(path.join(monacoRoot, "min", "vs", asset))).toBe(
-        true,
-      );
-    }
-  });
-
-  test("does not bring a second copy of anything Common already depends on", () => {
-    /*
-     * Monaco releases from 0.55 on depend on marked and dompurify, both of which
-     * Common already pins at the top level. npm nests Monaco's own copies
-     * because it pins them exactly, so the top-level pin does not reach them and
-     * the tree ends up carrying two versions - the older one being whatever
-     * Monaco vendored at release time.
-     */
-    const monacoDependencies: Array<string> = Object.keys(
-      JSON.parse(
-        fs.readFileSync(require.resolve("monaco-editor/package.json"), "utf8"),
-      ).dependencies || {},
-    );
-
-    const commonDependencies: Record<string, string> = JSON.parse(
-      fs.readFileSync(path.join(__dirname, "../../../package.json"), "utf8"),
-    ).dependencies;
-
-    expect(
-      monacoDependencies.filter((name: string) => {
-        return Boolean(commonDependencies[name]);
-      }),
-    ).toEqual([]);
-  });
-});

package/Tests/UI/Components/Telemetry/TelemetryRetentionConfigForm.test.tsx

@@ -1,329 +0,0 @@
-import "@testing-library/jest-dom";
-import { afterEach, describe, expect, test } from "@jest/globals";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import React from "react";
-import TelemetryRetentionConfigForm from "../../../../UI/Components/Telemetry/TelemetryRetentionConfigForm";
-import TelemetryRetentionConfig from "../../../../Types/Telemetry/TelemetryRetentionConfig";
-import LogSeverity from "../../../../Types/Log/LogSeverity";
-import { SpanStatus } from "../../../../Models/AnalyticsModels/Span";
-
-/*
- * This form decides when a customer's telemetry is deleted, so the values it
- * emits are not a display concern - they are how long the data exists.
- *
- * Two shapes have to be exactly right and neither is visible from reading the
- * form:
- *
- *  - A cleared field must REMOVE its key, all the way up. A pillar left as
- *    `{}`, or a `bySeverity` left with no entries, is not the same thing as
- *    "no override": it is a configuration object that exists. The whole
- *    config has to collapse to null when nothing is overridden at all.
- *  - A value that is not a positive number of days must clear the field
- *    rather than be stored. Storing 0 or -1 as a retention means data deleted
- *    on the next sweep, from a field the customer was in the middle of
- *    typing.
- */
-
-const emitted: Array<TelemetryRetentionConfig | null> = [];
-
-function renderForm(value?: TelemetryRetentionConfig): void {
-  emitted.length = 0;
-  render(
-    <TelemetryRetentionConfigForm
-      value={value}
-      onChange={(next: TelemetryRetentionConfig | null): void => {
-        emitted.push(next);
-      }}
-    />,
-  );
-}
-
-function lastEmitted(): TelemetryRetentionConfig | null {
-  return emitted[emitted.length - 1] as TelemetryRetentionConfig | null;
-}
-
-/*
- * The four pillar inputs share a placeholder and appear in the order their
- * sections do. "renders the four pillars in a known order" pins that order,
- * so these indices mean what they say.
- */
-const PILLAR: Record<string, number> = {
-  logs: 0,
-  traces: 1,
-  metrics: 2,
-  profiles: 3,
-};
-
-function pillarInput(pillar: string): HTMLElement {
-  return screen.getAllByPlaceholderText("Use default retention")[
-    PILLAR[pillar] as number
-  ] as HTMLElement;
-}
-
-function severityInput(index: number): HTMLElement {
-  return screen.getAllByPlaceholderText("Use logs default")[
-    index
-  ] as HTMLElement;
-}
-
-function statusInput(index: number): HTMLElement {
-  return screen.getAllByPlaceholderText("Use traces default")[
-    index
-  ] as HTMLElement;
-}
-
-function type(element: HTMLElement, value: string): void {
-  fireEvent.change(element, { target: { value: value } });
-}
-
-afterEach(() => {
-  cleanup();
-});
-
-describe("TelemetryRetentionConfigForm: layout", () => {
-  test("renders the four pillars in a known order", () => {
-    renderForm();
-
-    const headings: Array<string> = screen
-      .getAllByRole("heading")
-      .map((heading: HTMLElement): string => {
-        return heading.textContent || "";
-      });
-
-    expect(headings).toEqual(["Logs", "Traces", "Metrics", "Profiles"]);
-    expect(
-      screen.getAllByPlaceholderText("Use default retention"),
-    ).toHaveLength(4);
-  });
-
-  test("offers an override for every log severity and span status", () => {
-    renderForm();
-
-    expect(screen.getAllByPlaceholderText("Use logs default")).toHaveLength(7);
-    expect(screen.getAllByPlaceholderText("Use traces default")).toHaveLength(
-      3,
-    );
-  });
-
-  test("starts empty when there is no configuration", () => {
-    renderForm();
-
-    expect(pillarInput("logs")).toHaveValue(null);
-    expect(severityInput(0)).toHaveValue(null);
-  });
-
-  test("shows the values it was given", () => {
-    renderForm({
-      logs: { default: 30, bySeverity: { [LogSeverity.Error]: 90 } },
-      metrics: { default: 15 },
-    });
-
-    expect(pillarInput("logs")).toHaveValue(30);
-    expect(pillarInput("metrics")).toHaveValue(15);
-    expect(severityInput(1)).toHaveValue(90);
-  });
-});
-
-describe("TelemetryRetentionConfigForm: pillar defaults", () => {
-  test.each(["logs", "traces", "metrics", "profiles"])(
-    "sets the %s default",
-    (pillar: string) => {
-      renderForm();
-      type(pillarInput(pillar), "45");
-
-      expect(lastEmitted()).toEqual({ [pillar]: { default: 45 } });
-    },
-  );
-
-  test("keeps the pillars independent of one another", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    type(pillarInput("metrics"), "15");
-
-    expect(lastEmitted()).toEqual({
-      logs: { default: 30 },
-      metrics: { default: 15 },
-    });
-  });
-
-  /*
-   * Collapsing to null is what tells the caller "no overrides at all, use the
-   * platform defaults". An empty object is a configuration that exists and
-   * overrides nothing, which is a different thing to everything reading it.
-   */
-  test("emits null once the last override is cleared", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    expect(lastEmitted()).toEqual({ logs: { default: 30 } });
-
-    type(pillarInput("logs"), "");
-    expect(lastEmitted()).toBeNull();
-  });
-
-  test("drops only the cleared pillar while another still has a value", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    type(pillarInput("traces"), "10");
-    type(pillarInput("logs"), "");
-
-    expect(lastEmitted()).toEqual({ traces: { default: 10 } });
-  });
-
-  /*
-   * A retention of zero or less is not a shorter retention, it is immediate
-   * deletion - and it is what a half-typed "-" or a "0" on the way to "30"
-   * looks like. Treat it as no override rather than store it.
-   */
-  test.each(["0", "-1", "-30"])(
-    "treats %s days as no override rather than as a retention",
-    (value: string) => {
-      renderForm();
-      type(pillarInput("logs"), value);
-
-      expect(lastEmitted()).toBeNull();
-    },
-  );
-
-  test("truncates a fractional number of days", () => {
-    renderForm();
-    type(pillarInput("logs"), "7.9");
-
-    expect(lastEmitted()).toEqual({ logs: { default: 7 } });
-  });
-
-  /*
-   * The dangerous middle. "0.9" is greater than zero, so a positivity check
-   * made before truncating let it through - and Math.trunc(0.9) is 0, a
-   * retention of zero days, which deletes that pillar's telemetry on the
-   * next sweep. Whole days are the only unit here: less than one day is an
-   * empty field, not an instruction.
-   */
-  test.each(["0.9", "0.1", "0.0001"])(
-    "treats %s of a day as an empty field, not as zero days",
-    (value: string) => {
-      renderForm();
-      type(pillarInput("logs"), value);
-
-      expect(lastEmitted()).toBeNull();
-    },
-  );
-});
-
-describe("TelemetryRetentionConfigForm: per-severity overrides", () => {
-  /*
-   * Severity inputs follow the order the form lists them: Fatal, Error,
-   * Warning, Information, Debug, Trace, Unspecified.
-   */
-  test("adds an override under the severity it belongs to", () => {
-    renderForm();
-    type(severityInput(1), "90");
-
-    expect(lastEmitted()).toEqual({
-      logs: { bySeverity: { [LogSeverity.Error]: 90 } },
-    });
-  });
-
-  test("keeps the logs default alongside a severity override", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    type(severityInput(1), "90");
-
-    expect(lastEmitted()).toEqual({
-      logs: { default: 30, bySeverity: { [LogSeverity.Error]: 90 } },
-    });
-  });
-
-  test("clears one severity without touching the others", () => {
-    renderForm();
-    type(severityInput(1), "90");
-    type(severityInput(0), "180");
-    type(severityInput(1), "");
-
-    expect(lastEmitted()).toEqual({
-      logs: { bySeverity: { [LogSeverity.Fatal]: 180 } },
-    });
-  });
-
-  /*
-   * Removing the last severity has to remove bySeverity itself, and then
-   * logs itself - an empty map left behind is a map that exists.
-   */
-  test("removes the map, then the pillar, when the last override goes", () => {
-    renderForm();
-    type(severityInput(1), "90");
-    type(severityInput(1), "");
-
-    expect(lastEmitted()).toBeNull();
-  });
-
-  test("leaves the logs default behind when the last severity override goes", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    type(severityInput(1), "90");
-    type(severityInput(1), "");
-
-    expect(lastEmitted()).toEqual({ logs: { default: 30 } });
-  });
-
-  test.each(["0", "-5"])(
-    "treats a severity override of %s as no override",
-    (value: string) => {
-      renderForm();
-      type(severityInput(1), value);
-
-      expect(lastEmitted()).toBeNull();
-    },
-  );
-});
-
-describe("TelemetryRetentionConfigForm: per-status overrides", () => {
-  // Status inputs follow the order the form lists them: Error, Ok, Unset.
-  test("adds an override under the span status it belongs to", () => {
-    renderForm();
-    type(statusInput(0), "60");
-
-    expect(lastEmitted()).toEqual({
-      traces: { byStatus: { [SpanStatus.Error]: 60 } },
-    });
-  });
-
-  test("keeps the traces default alongside a status override", () => {
-    renderForm();
-    type(pillarInput("traces"), "7");
-    type(statusInput(0), "60");
-
-    expect(lastEmitted()).toEqual({
-      traces: { default: 7, byStatus: { [SpanStatus.Error]: 60 } },
-    });
-  });
-
-  test("clears one status without touching the others", () => {
-    renderForm();
-    type(statusInput(0), "60");
-    type(statusInput(1), "3");
-    type(statusInput(0), "");
-
-    expect(lastEmitted()).toEqual({
-      traces: { byStatus: { [SpanStatus.Ok]: 3 } },
-    });
-  });
-
-  test("removes the map, then the pillar, when the last override goes", () => {
-    renderForm();
-    type(statusInput(0), "60");
-    type(statusInput(0), "");
-
-    expect(lastEmitted()).toBeNull();
-  });
-
-  test("does not disturb the other pillars", () => {
-    renderForm();
-    type(pillarInput("logs"), "30");
-    type(statusInput(0), "60");
-
-    expect(lastEmitted()).toEqual({
-      logs: { default: 30 },
-      traces: { byStatus: { [SpanStatus.Error]: 60 } },
-    });
-  });
-});