@oneuptime/common 11.5.4 → 11.5.6

package/Tests/Types/Workflow/AIGenerateTextMetadata.test.ts

@@ -0,0 +1,180 @@
+import Components, { Categories } from "../../../Types/Workflow/Components";
+import AIComponents from "../../../Types/Workflow/Components/AI";
+import ComponentID from "../../../Types/Workflow/ComponentID";
+import ComponentMetadata, {
+  Argument,
+  ComponentCategory,
+  ComponentInputType,
+  ComponentType,
+  Port,
+  ReturnValue,
+} from "../../../Types/Workflow/Component";
+import { describe, expect, test } from "@jest/globals";
+
+function byId<T extends { id: string }>(items: Array<T>, id: string): T {
+  const item: T | undefined = items.find((candidate: T) => {
+    return candidate.id === id;
+  });
+
+  if (!item) {
+    throw new Error(`Expected item with id ${id}`);
+  }
+
+  return item;
+}
+
+describe("Generate Text with AI workflow metadata", () => {
+  const metadata: ComponentMetadata = byId(
+    AIComponents,
+    ComponentID.AIGenerateText,
+  );
+
+  test("uses the stable persisted component id", () => {
+    expect(ComponentID.AIGenerateText).toBe("ai-generate-text");
+    expect(metadata.id).toBe("ai-generate-text");
+  });
+
+  test("is a discoverable AI component", () => {
+    expect(metadata.title).toBe("Generate Text with AI");
+    expect(metadata.category).toBe("AI");
+    expect(metadata.componentType).toBe(ComponentType.Component);
+    expect(metadata.description).toMatch(/AI|LLM/i);
+    expect(metadata.iconProp).toBeDefined();
+
+    expect(
+      Components.filter((component: ComponentMetadata) => {
+        return component.id === ComponentID.AIGenerateText;
+      }),
+    ).toHaveLength(1);
+    expect(
+      Categories.some((category: ComponentCategory) => {
+        return category.name === "AI";
+      }),
+    ).toBe(true);
+  });
+
+  test("publishes the complete, stable argument contract", () => {
+    expect(
+      metadata.arguments.map((argument: Argument) => {
+        return argument.id;
+      }),
+    ).toEqual([
+      "system-prompt",
+      "prompt",
+      "context",
+      "temperature",
+      "max-output-tokens",
+    ]);
+
+    expect(byId(metadata.arguments, "prompt")).toMatchObject({
+      required: true,
+      type: ComponentInputType.Markdown,
+    });
+    expect(byId(metadata.arguments, "system-prompt")).toMatchObject({
+      required: false,
+      type: ComponentInputType.LongText,
+    });
+    expect(byId(metadata.arguments, "context")).toMatchObject({
+      required: false,
+      type: ComponentInputType.JSON,
+    });
+    expect(byId(metadata.arguments, "temperature")).toMatchObject({
+      required: false,
+      type: ComponentInputType.Decimal,
+    });
+    expect(byId(metadata.arguments, "max-output-tokens")).toMatchObject({
+      required: false,
+      type: ComponentInputType.Number,
+    });
+  });
+
+  test("does not expose provider credentials or arbitrary endpoints as inputs", () => {
+    const argumentIds: Array<string> = metadata.arguments.map(
+      (argument: Argument) => {
+        return argument.id.toLowerCase();
+      },
+    );
+
+    expect(argumentIds).not.toContain("api-key");
+    expect(argumentIds).not.toContain("provider");
+    expect(argumentIds).not.toContain("provider-id");
+    expect(argumentIds).not.toContain("model");
+    expect(argumentIds).not.toContain("base-url");
+  });
+
+  test("marks prompt-bearing inputs as sensitive workflow-log data", () => {
+    for (const id of ["prompt", "system-prompt", "context"]) {
+      expect(byId(metadata.arguments, id).isSensitive).toBe(true);
+    }
+
+    expect(byId(metadata.arguments, "temperature").isSensitive).not.toBe(true);
+    expect(byId(metadata.arguments, "max-output-tokens").isSensitive).not.toBe(
+      true,
+    );
+  });
+
+  test("publishes typed usage and diagnostic return values", () => {
+    expect(
+      metadata.returnValues.map((returnValue: ReturnValue) => {
+        return returnValue.id;
+      }),
+    ).toEqual([
+      "response",
+      "provider",
+      "model",
+      "total-tokens",
+      "completion-tokens",
+      "llm-log-id",
+      "error",
+    ]);
+
+    expect(byId(metadata.returnValues, "response").type).toBe(
+      ComponentInputType.LongText,
+    );
+    expect(byId(metadata.returnValues, "provider").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "model").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "total-tokens").type).toBe(
+      ComponentInputType.Number,
+    );
+    expect(byId(metadata.returnValues, "completion-tokens").type).toBe(
+      ComponentInputType.Number,
+    );
+    expect(byId(metadata.returnValues, "llm-log-id").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "error").type).toBe(
+      ComponentInputType.Text,
+    );
+  });
+
+  test("redacts model-generated content while leaving usage metadata loggable", () => {
+    expect(byId(metadata.returnValues, "response").isSensitive).toBe(true);
+
+    for (const id of [
+      "provider",
+      "model",
+      "total-tokens",
+      "completion-tokens",
+      "llm-log-id",
+    ]) {
+      expect(byId(metadata.returnValues, id).isSensitive).not.toBe(true);
+    }
+  });
+
+  test("has one input port and explicit success and error branches", () => {
+    expect(
+      metadata.inPorts.map((port: Port) => {
+        return port.id;
+      }),
+    ).toEqual(["in"]);
+    expect(
+      metadata.outPorts.map((port: Port) => {
+        return port.id;
+      }),
+    ).toEqual(["success", "error"]);
+  });
+});

package/Tests/UI/Components/TableBulkCsvExport.test.tsx

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import { fireEvent, render, RenderResult } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import Table, { BulkActionProps } from "../../../UI/Components/Table/Table";
+import Columns from "../../../UI/Components/Table/Types/Columns";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { ButtonStyleType } from "../../../UI/Components/Button/Button";
+
+/*
+ * react-i18next is not initialized in the test environment. Mock the hook so
+ * translate helpers echo their input and the Table renders synchronously.
+ */
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string, opts?: { defaultValue?: string }): string => {
+          return opts?.defaultValue ?? key;
+        },
+      };
+    },
+  };
+});
+
+interface Row {
+  _id?: string | undefined;
+  name?: string | undefined;
+}
+
+const columns: Columns<Row> = [
+  { title: "Name", type: FieldType.Text, key: "name" },
+];
+
+const data: Array<Row> = [
+  { _id: "1", name: "Alpha" },
+  { _id: "2", name: "Beta" },
+];
+
+interface RenderTableOptions {
+  bulkActions?: BulkActionProps<Row> | undefined;
+  bulkSelectedItems?: Array<Row> | undefined;
+  disableBulkCsvExport?: boolean | undefined;
+}
+
+type RenderTableFunction = (options: RenderTableOptions) => RenderResult;
+
+const renderTable: RenderTableFunction = (
+  options: RenderTableOptions,
+): RenderResult => {
+  return render(
+    <Table<Row>
+      id="test-table"
+      data={data}
+      columns={columns}
+      currentPageNumber={1}
+      totalItemsCount={data.length}
+      itemsOnPage={10}
+      error=""
+      isLoading={false}
+      singularLabel="Monitor"
+      pluralLabel="Monitors"
+      sortOrder={SortOrder.Ascending}
+      sortBy={null}
+      onSortChanged={() => {}}
+      onNavigateToPage={() => {}}
+      matchBulkSelectedItemByField="_id"
+      bulkActions={options.bulkActions}
+      bulkSelectedItems={options.bulkSelectedItems}
+      disableBulkCsvExport={options.disableBulkCsvExport}
+    />,
+  );
+};
+
+const customBulkActions: BulkActionProps<Row> = {
+  buttons: [
+    {
+      title: "Archive",
+      buttonStyleType: ButtonStyleType.NORMAL,
+      onClick: (): Promise<void> => {
+        return Promise.resolve();
+      },
+    },
+  ],
+};
+
+describe("Table bulk CSV export", () => {
+  let createObjectURLMock: MockFunction;
+  let revokeObjectURLMock: MockFunction;
+  let clickSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    createObjectURLMock = getJestMockFunction();
+    createObjectURLMock.mockReturnValue("blob:mock-url");
+    revokeObjectURLMock = getJestMockFunction();
+
+    (window.URL as unknown as { createObjectURL: unknown }).createObjectURL =
+      createObjectURLMock;
+    (window.URL as unknown as { revokeObjectURL: unknown }).revokeObjectURL =
+      revokeObjectURLMock;
+
+    clickSpy = jest
+      .spyOn(HTMLAnchorElement.prototype, "click")
+      .mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    clickSpy.mockRestore();
+  });
+
+  test("shows an Export CSV action when the table has bulk actions and rows are selected", () => {
+    const { getByText } = renderTable({
+      bulkActions: customBulkActions,
+      bulkSelectedItems: [data[0]!],
+    });
+
+    // The bulk action bar is visible with the selected count.
+    expect(getByText("1 Monitors Selected")).toBeTruthy();
+
+    // Open the Bulk Actions menu.
+    fireEvent.click(getByText("Bulk Actions"));
+
+    // Both the table's own action and the injected Export CSV are present.
+    expect(getByText("Archive")).toBeTruthy();
+    expect(getByText("Export CSV")).toBeTruthy();
+  });
+
+  test("clicking Export CSV triggers a client-side CSV download of the selection", () => {
+    const { getByText } = renderTable({
+      bulkActions: customBulkActions,
+      bulkSelectedItems: [data[0]!],
+    });
+
+    fireEvent.click(getByText("Bulk Actions"));
+    fireEvent.click(getByText("Export CSV"));
+
+    expect(createObjectURLMock).toHaveBeenCalledTimes(1);
+    expect(clickSpy).toHaveBeenCalledTimes(1);
+
+    const blobArg: Blob = createObjectURLMock.mock.calls[0]![0] as Blob;
+    expect(blobArg).toBeInstanceOf(Blob);
+    expect(blobArg.type).toContain("text/csv");
+  });
+
+  test("does not inject Export CSV when disableBulkCsvExport is set", () => {
+    const { getByText, queryByText } = renderTable({
+      bulkActions: customBulkActions,
+      bulkSelectedItems: [data[0]!],
+      disableBulkCsvExport: true,
+    });
+
+    fireEvent.click(getByText("Bulk Actions"));
+
+    expect(getByText("Archive")).toBeTruthy();
+    expect(queryByText("Export CSV")).toBeNull();
+  });
+
+  test("does not render the bulk action bar (or Export CSV) when there are no bulk actions", () => {
+    const { queryByText } = renderTable({
+      bulkActions: undefined,
+      bulkSelectedItems: [data[0]!],
+    });
+
+    expect(queryByText("Bulk Actions")).toBeNull();
+    expect(queryByText("Export CSV")).toBeNull();
+  });
+});