Skip to content

πŸ™Œ OpenHands: AI-Driven Development

test: cover automations list workflows (#17370)

aivong-openhandsb06a05dc928c
diff --git a/__tests__/routes/automations-dashboard.test.tsx b/__tests__/routes/automations-dashboard.test.tsx
index 7f05657c77..d192b72803 100644
--- a/__tests__/routes/automations-dashboard.test.tsx
+++ b/__tests__/routes/automations-dashboard.test.tsx
@@ -148,6 +148,40 @@ afterEach(() => {
});
describe("AutomationsList β€” manifest-declared dashboard", () => {
+ it("shows zero automations while the initial list request is pending", async () => {
+ vi.mocked(AutomationService.getAutomations).mockReturnValue(
+ new Promise(() => {}),
+ );
+
+ renderAt("/automations", <AutomationsList />);
+
+ await waitFor(() =>
+ expect(AutomationService.getAutomations).toHaveBeenCalled(),
+ );
+ const tile = screen.getByTestId("overview-tile-automations");
+ expect(within(tile).getByText("0", { exact: true })).toBeInTheDocument();
+ expect(within(tile).getByText("0 live")).toBeInTheDocument();
+ });
+
+ it("uses the manifest's zero detail when no automation needs attention", async () => {
+ vi.mocked(AutomationService.getAutomationRuns).mockResolvedValue({
+ runs: [createRun({})],
+ total: 1,
+ });
+
+ renderAt("/automations", <AutomationsList />);
+
+ await within(
+ await screen.findByTestId("automation-card-a-broken"),
+ ).findByTestId("run-status-icon-completed");
+ const tile = screen.getByTestId("overview-tile-needs-attention");
+ expect(within(tile).getByText("0", { exact: true })).toBeInTheDocument();
+ expect(within(tile).getByText("No broken widgets")).toBeInTheDocument();
+ expect(
+ within(tile).queryByText("Broken widgets", { exact: true }),
+ ).toBeNull();
+ });
+
it("composes the manifest's sub-page surface around the list", async () => {
// Arrange & Act
await renderDashboardWithSettledInsights();
diff --git a/__tests__/routes/automations-list-behavior.test.tsx b/__tests__/routes/automations-list-behavior.test.tsx
new file mode 100644
index 0000000000..a90a578ec5
--- /dev/null
+++ b/__tests__/routes/automations-list-behavior.test.tsx
@@ -0,0 +1,1132 @@
+import React from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { I18nKey } from "#/i18n/declaration";
+import type { Automation, AutomationSpec } from "#/types/automation";
+
+const mocks = vi.hoisted(() => ({
+ healthState: {
+ data: { status: "ok" } as { status: string } | undefined,
+ isLoading: false,
+ refetch: vi.fn(),
+ },
+ automationsState: {
+ data: { automations: [], total: 0 } as
+ | { automations: Automation[]; total: number }
+ | undefined,
+ isLoading: false,
+ isError: false,
+ refetch: vi.fn(),
+ },
+ dispatchState: {
+ isPending: false,
+ variables: undefined as string | undefined,
+ },
+ importState: { isPending: false },
+ backendKind: "local" as "local" | "cloud",
+ canManage: true,
+ navigate: vi.fn(),
+ useAutomations: vi.fn(),
+ useAutomationRunSummaries: vi.fn(),
+ toggle: vi.fn(),
+ remove: vi.fn(),
+ dispatch: vi.fn(),
+ importAutomation: vi.fn(),
+ trackEnabled: vi.fn(),
+ trackExported: vi.fn(),
+ useTranslation: vi.fn(),
+ translate: vi.fn((key: string) => key),
+ successToast: vi.fn(),
+ successToastWithLink: vi.fn(),
+ errorToast: vi.fn(),
+ serializeAutomation: vi.fn(),
+ parseAutomationFile: vi.fn(),
+ exportFilename: vi.fn(),
+ downloadBlob: vi.fn(),
+}));
+
+vi.mock("react-i18next", () => ({
+ useTranslation: (namespace: string) => {
+ mocks.useTranslation(namespace);
+ return { t: mocks.translate };
+ },
+}));
+
+// Pin the published data source to a manifest that declares no dashboard or
+// sub-page surface so the route renders in its plain-list form β€” the behavior
+// this suite exercises β€” independent of whatever the pinned package ships.
+vi.mock("#/manifests/manifest-sources", async (importOriginal) => {
+ const actual =
+ await importOriginal<typeof import("#/manifests/manifest-sources")>();
+ const { createInterfaceManifest } =
+ await import("../manifests/manifest-test-data");
+ return {
+ ...actual,
+ AUTOMATION_INTERFACE_CANDIDATE: createInterfaceManifest(),
+ };
+});
+
+vi.mock("#/hooks/use-automation-permissions", () => ({
+ useAutomationPermissions: () => ({ canManage: mocks.canManage }),
+}));
+
+vi.mock("#/context/navigation-context", () => ({
+ useNavigation: () => ({ navigate: mocks.navigate }),
+}));
+
+vi.mock("#/hooks/query/use-automation-run-summaries", () => ({
+ useAutomationRunSummaries: (automations: Automation[], options: unknown) => {
+ mocks.useAutomationRunSummaries(automations, options);
+ return {};
+ },
+}));
+
+vi.mock("#/hooks/query/use-automation-health", () => ({
+ useAutomationHealth: () => mocks.healthState,
+}));
+
+vi.mock("#/hooks/query/use-automations", () => ({
+ useAutomations: (options: unknown) => {
+ mocks.useAutomations(options);
+ return mocks.automationsState;
+ },
+ useToggleAutomation: () => ({ mutate: mocks.toggle }),
+ useDeleteAutomation: () => ({ mutate: mocks.remove }),
+ useDispatchAutomation: () => ({
+ mutate: mocks.dispatch,
+ ...mocks.dispatchState,
+ }),
+ useImportAutomation: () => ({
+ mutate: mocks.importAutomation,
+ ...mocks.importState,
+ }),
+}));
+
+vi.mock("#/contexts/active-backend-context", () => ({
+ useActiveBackend: () => ({
+ backend: { id: "backend-1", kind: mocks.backendKind },
+ }),
+}));
+
+vi.mock("#/hooks/use-tracking", () => ({
+ useTracking: () => ({
+ trackPrebuiltAutomationEnabled: mocks.trackEnabled,
+ trackAutomationExported: mocks.trackExported,
+ }),
+}));
+
+vi.mock("#/utils/custom-toast-handlers", () => ({
+ displaySuccessToast: mocks.successToast,
+ displaySuccessToastWithLink: mocks.successToastWithLink,
+ displayErrorToast: mocks.errorToast,
+}));
+
+vi.mock("#/utils/automation-export", () => ({
+ serializeAutomation: mocks.serializeAutomation,
+ parseAutomationFile: mocks.parseAutomationFile,
+ getAutomationExportFilename: mocks.exportFilename,
+}));
+
+vi.mock("#/utils/utils", () => ({
+ downloadBlob: mocks.downloadBlob,
+ cn: (...classes: unknown[]) => classes.filter(Boolean).join(" "),
+}));
+
+vi.mock("#/components/features/automations/search-input", () => ({
+ SearchInput: ({
+ value,
+ onChange,
+ }: {
+ value: string;
+ onChange: (value: string) => void;
+ }) => (
+ <input
+ aria-label="automation-search"
+ value={value}
+ onChange={(event) => onChange(event.target.value)}
+ />
+ ),
+}));
+
+interface AutomationGroupProps {
+ title: string;
+ count: number;
+ automations: Automation[];
+ view: string;
+ runPendingId: string | null;
+ onToggle: (id: string, enabled: boolean) => void;
+ onRunNow: (id: string) => void;
+ onDelete: (id: string) => void;
+ onExport: (automation: Automation) => void;
+ onEdit?: (id: string) => void;
+}
+
+vi.mock("#/components/features/automations/automation-group", () => ({
+ AutomationGroup: ({
+ title,
+ count,
+ automations,
+ view,
+ runPendingId,
+ onToggle,
+ onRunNow,
+ onDelete,
+ onExport,
+ onEdit,
+ }: AutomationGroupProps) => (
+ <section aria-label={title} data-count={count} data-view={view}>
+ <output data-testid={`pending-${title}`}>{runPendingId ?? "none"}</output>
+ <button type="button" onClick={() => onToggle("missing-id", false)}>
+ stale-toggle-{title}
+ </button>
+ <button type="button" onClick={() => onDelete("missing-id")}>
+ stale-delete-{title}
+ </button>
+ {onEdit && (
+ <button type="button" onClick={() => onEdit("missing-id")}>
+ stale-edit-{title}
+ </button>
+ )}
+ {automations.map((automation) => (
+ <article
+ key={automation.id}
+ data-testid={`automation-${automation.id}`}
+ >
+ <span>{automation.name}</span>
+ <button
+ type="button"
+ onClick={() => onToggle(automation.id, automation.enabled)}
+ >
+ toggle-{automation.id}
+ </button>
+ <button type="button" onClick={() => onRunNow(automation.id)}>
+ run-{automation.id}
+ </button>
+ <button type="button" onClick={() => onDelete(automation.id)}>
+ delete-{automation.id}
+ </button>
+ <button type="button" onClick={() => onExport(automation)}>
+ export-{automation.id}
+ </button>
+ {onEdit && (
+ <button type="button" onClick={() => onEdit(automation.id)}>
+ edit-{automation.id}
+ </button>
+ )}
+ </article>
+ ))}
+ </section>
+ ),
+}));
+
+vi.mock("#/components/features/automations/automation-view-toggle", () => ({
+ AutomationViewToggle: ({
+ view,
+ onChange,
+ disabled,
+ }: {
+ view: string;
+ onChange: (view: "grid" | "list") => void;
+ disabled: boolean;
+ }) => (
+ <button
+ type="button"
+ disabled={disabled}
+ data-testid="view-toggle"
+ onClick={() => onChange(view === "grid" ? "list" : "grid")}
+ >
+ {view}
+ </button>
+ ),
+}));
+
+vi.mock("#/components/features/automations/automation-card-skeleton", () => ({
+ AutomationCardSkeleton: () => <div data-testid="automation-skeleton" />,
+}));
+
+vi.mock("#/components/features/automations/empty-state", () => ({
+ EmptyState: () => <div data-testid="empty-state" />,
+}));
+
+vi.mock("#/components/features/automations/error-state", () => ({
+ ErrorState: ({ onRetry }: { onRetry: () => void }) => (
+ <button type="button" onClick={onRetry}>
+ retry-list
+ </button>
+ ),
+}));
+
+vi.mock("#/components/features/automations/backend-not-configured", () => ({
+ BackendNotConfigured: ({ onRetry }: { onRetry: () => void }) => (
+ <button type="button" onClick={onRetry}>
+ retry-health
+ </button>
+ ),
+}));
+
+vi.mock("#/components/features/automations/delete-confirmation-modal", () => ({
+ DeleteConfirmationModal: ({
+ automationName,
+ isOpen,
+ onConfirm,
+ onCancel,
+ }: {
+ automationName: string;
+ isOpen: boolean;
+ onConfirm: () => void;
+ onCancel: () => void;
+ }) =>
+ isOpen ? (
+ <div data-testid="delete-modal">
+ <span>{automationName}</span>
+ <button type="button" onClick={onConfirm}>
+ confirm-delete
+ </button>
+ <button type="button" onClick={onCancel}>
+ cancel-delete
+ </button>
+ </div>
+ ) : null,
+}));
+
+vi.mock(
+ "#/components/features/automations/detail/edit-automation-modal",
+ () => ({
+ EditAutomationModal: ({
+ automation,
+ isOpen,
+ onClose,
+ }: {
+ automation: Automation;
+ isOpen: boolean;
+ onClose: () => void;
+ }) =>
+ isOpen ? (
+ <div data-testid="edit-modal">
+ <span>{automation.name}</span>
+ <button type="button" onClick={onClose}>
+ close-edit
+ </button>
+ </div>
+ ) : null,
+ }),
+);
+
+vi.mock("#/components/features/automations/add-automation-modal", () => ({
+ AddAutomationModal: ({
+ isOpen,
+ onClose,
+ }: {
+ isOpen: boolean;
+ onClose: () => void;
+ }) =>
+ isOpen ? (
+ <div data-testid="add-modal">
+ <button type="button" onClick={onClose}>
+ close-add
+ </button>
+ </div>
+ ) : null,
+}));
+
+vi.mock("#/components/features/automations/import-automation-modal", () => ({
+ ImportAutomationModal: ({
+ isOpen,
+ spec,
+ isImporting,
+ onClose,
+ onImport,
+ onFile,
+ }: {
+ isOpen: boolean;
+ spec: AutomationSpec | null;
+ isImporting: boolean;
+ onClose: () => void;
+ onImport: () => void;
+ onFile: (file: File) => void;
+ }) =>
+ isOpen ? (
+ <div data-testid="import-modal" data-importing={isImporting}>
+ <span>{spec?.name}</span>
+ <input
+ type="file"
+ data-testid="automations-import-file"
+ onChange={(event) => {
+ const file = event.target.files?.[0];
+ if (file) onFile(file);
+ }}
+ />
+ <button type="button" onClick={onImport}>
+ confirm-import
+ </button>
+ <button type="button" onClick={onClose}>
+ close-import
+ </button>
+ </div>
+ ) : null,
+}));
+
+vi.mock(
+ "#/components/features/automations/recommended-automations-launcher",
+ () => ({
+ RecommendedAutomationsLauncher: ({ query }: { query: string }) => (
+ <output data-testid="recommended-query">{query}</output>
+ ),
+ }),
+);
+
+vi.mock("#/components/features/settings/brand-button", () => ({
+ BrandButton: ({
+ children,
+ onClick,
+ testId,
+ }: {
+ children: React.ReactNode;
+ onClick?: () => void;
+ testId?: string;
+ }) => (
+ <button type="button" data-testid={testId} onClick={onClick}>
+ {children}
+ </button>
+ ),
+}));
+
+vi.mock("#/components/features/automations/add-automation-menu", () => ({
+ AddAutomationMenu: ({
+ onAdd,
+ onImport,
+ isAddDisabled,
+ }: {
+ onAdd: () => void;
+ onImport: () => void;
+ isAddDisabled?: boolean;
+ }) => (
+ <div>
+ <button
+ type="button"
+ data-testid="automations-add-automation"
+ disabled={isAddDisabled}
+ onClick={onAdd}
+ >
+ add-automation
+ </button>
+ <button
+ type="button"
+ data-testid="automations-import-automation"
+ onClick={onImport}
+ >
+ import-automation
+ </button>
+ </div>
+ ),
+}));
+
+import AutomationsList, { clientLoader } from "#/routes/automations-list";
+
+function makeAutomation(overrides: Partial<Automation> = {}): Automation {
+ return {
+ id: "automation-1",
+ name: "Daily digest",
+ prompt: "Summarize pull requests",
+ trigger: { type: "cron", schedule: "0 9 * * *" },
+ enabled: true,
+ repository: "openhands/agent-canvas",
+ model: "fast-model",
+ created_at: "2026-01-01T00:00:00Z",
+ updated_at: "2026-01-01T00:00:00Z",
+ ...overrides,
+ };
+}
+
+function makeImportSpec(
+ overrides: Partial<AutomationSpec> = {},
+): AutomationSpec {
+ return {
+ name: "Imported automation",
+ prompt: "Review a change",
+ trigger: { type: "cron", schedule: "0 10 * * *" },
+ enabled: true,
+ ...overrides,
+ };
+}
+
+function renderList() {
+ return render(<AutomationsList />);
+}
+
+function openImportModal() {
+ fireEvent.click(screen.getByTestId("automations-import-automation"));
+}
+
+function uploadFile(text: string) {
+ if (!screen.queryByTestId("automations-import-file")) {
+ openImportModal();
+ }
+ const input = screen.getByTestId("automations-import-file");
+ const file = new File([text], "automation.json", {
+ type: "application/json",
+ });
+ Object.defineProperty(file, "text", {
+ configurable: true,
+ value: vi.fn().mockResolvedValue(text),
+ });
+ fireEvent.change(input, { target: { files: [file] } });
+ return input as HTMLInputElement;
+}
+
+function readBlobText(blob: Blob): Promise<string> {
+ return new Promise((resolve, reject) => {
+ const reader = new FileReader();
+ reader.addEventListener("load", () => resolve(String(reader.result)));
+ reader.addEventListener("error", () => reject(reader.error));
+ reader.readAsText(blob);
+ });
+}
+
+beforeEach(() => {
+ mocks.canManage = true;
+ vi.clearAllMocks();
+ window.localStorage.clear();
+ mocks.healthState.data = { status: "ok" };
+ mocks.healthState.isLoading = false;
+ mocks.automationsState.data = { automations: [], total: 0 };
+ mocks.automationsState.isLoading = false;
+ mocks.automationsState.isError = false;
+ mocks.dispatchState.isPending = false;
+ mocks.dispatchState.variables = undefined;
+ mocks.importState.isPending = false;
+ mocks.backendKind = "local";
+ mocks.serializeAutomation.mockReturnValue({
+ version: 1,
+ kind: "automation",
+ spec: makeImportSpec(),
+ });
+ mocks.exportFilename.mockReturnValue("daily-digest.automation.json");
+ mocks.parseAutomationFile.mockReturnValue(makeImportSpec());
+});
+
+describe("automations list states", () => {
+ it("keeps per-automation run queries disabled for the plain list", () => {
+ const automations = [makeAutomation()];
+ mocks.automationsState.data = { automations, total: 1 };
+
+ renderList();
+
+ expect(mocks.useAutomationRunSummaries).toHaveBeenCalledWith(automations, {
+ enabled: false,
+ });
+ });
+
+ it("shows health-check placeholders and waits to enable the list query", () => {
+ mocks.healthState.data = undefined;
+ mocks.healthState.isLoading = true;
+ mocks.automationsState.data = undefined;
+ mocks.automationsState.isLoading = true;
+
+ renderList();
+
+ expect(screen.getAllByTestId("automation-skeleton")).toHaveLength(3);
+ // The header copy comes from the admitted interface manifest.
+ expect(screen.getByText("Widget automations")).toBeInTheDocument();
+ expect(mocks.useAutomations).toHaveBeenCalledWith({
+ limit: 50,
+ offset: 0,
+ enabled: false,
+ });
+ expect(mocks.useTranslation).toHaveBeenCalledWith("openhands");
+ });
+
+ it("offers another health check when the backend is unavailable", async () => {
+ mocks.healthState.data = { status: "error" };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(screen.getByRole("button", { name: "retry-health" }));
+
+ expect(mocks.healthState.refetch).toHaveBeenCalledOnce();
+ });
+
+ it("shows list placeholders while healthy data is loading", () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 1,
+ };
+ mocks.automationsState.isLoading = true;
+
+ renderList();
+
+ expect(screen.getAllByTestId("automation-skeleton")).toHaveLength(3);
+ expect(screen.getByTestId("recommended-query")).toHaveTextContent("");
+ expect(
+ screen.queryByLabelText(I18nKey.AUTOMATIONS$ACTIVE),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "retry-list" }),
+ ).not.toBeInTheDocument();
+ expect(mocks.useAutomations).toHaveBeenCalledWith({
+ limit: 50,
+ offset: 0,
+ enabled: true,
+ });
+ });
+
+ it("offers another list request when loading fails", async () => {
+ mocks.automationsState.isError = true;
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(screen.getByRole("button", { name: "retry-list" }));
+
+ expect(mocks.automationsState.refetch).toHaveBeenCalledOnce();
+ expect(screen.queryByTestId("empty-state")).not.toBeInTheDocument();
+ });
+
+ it("shows an empty state and disables view changes for an empty list", () => {
+ renderList();
+
+ expect(screen.getByTestId("empty-state")).toBeInTheDocument();
+ expect(screen.getByTestId("view-toggle")).toBeDisabled();
+ expect(
+ screen.queryByRole("button", { name: "retry-list" }),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByLabelText(I18nKey.AUTOMATIONS$ACTIVE),
+ ).not.toBeInTheDocument();
+ });
+});
+
+describe("automations list interactions", () => {
+ it("admits the configured interface and opens Git Sync", () => {
+ expect(clientLoader()).toBeNull();
+ render(<AutomationsList />);
+ fireEvent.click(screen.getByTestId("automations-git-sync"));
+ expect(mocks.navigate).toHaveBeenCalledWith("/automations/git-sync");
+ });
+
+ it("filters saved automations by name, prompt, repository, and model", async () => {
+ const automations = [
+ makeAutomation({ id: "by-name", name: "Needle name" }),
+ makeAutomation({
+ id: "by-prompt",
+ name: "Second",
+ prompt: "Contains needle prompt",
+ enabled: false,
+ }),
+ makeAutomation({
+ id: "by-repository",
+ name: "Third",
+ prompt: null,
+ repository: "acme/needle-repository",
+ }),
+ makeAutomation({
+ id: "by-model",
+ name: "Fourth",
+ prompt: null,
+ repository: undefined,
+ model: "needle-model",
+ }),
+ makeAutomation({
+ id: "no-optional-values",
+ name: "Other",
+ prompt: null,
+ repository: undefined,
+ model: null,
+ }),
+ ];
+ mocks.automationsState.data = { automations, total: automations.length };
+ const user = userEvent.setup();
+
+ renderList();
+ expect(screen.getAllByTestId(/^automation-/)).toHaveLength(5);
+ expect(
+ screen.queryByRole("button", { name: "retry-list" }),
+ ).not.toBeInTheDocument();
+
+ const search = screen.getByRole("textbox", { name: "automation-search" });
+ await user.type(search, "needle name");
+ expect(screen.getByTestId("automation-by-name")).toBeInTheDocument();
+ expect(screen.getAllByTestId(/^automation-/)).toHaveLength(1);
+
+ await user.clear(search);
+ await user.type(search, "needle prompt");
+ expect(screen.getByTestId("automation-by-prompt")).toBeInTheDocument();
+
+ await user.clear(search);
+ await user.type(search, "needle-repository");
+ expect(screen.getByTestId("automation-by-repository")).toBeInTheDocument();
+
+ await user.clear(search);
+ await user.type(search, "NEEDLE-MODEL");
+ expect(screen.getByTestId("automation-by-model")).toBeInTheDocument();
+ expect(screen.getByTestId("recommended-query")).toHaveTextContent(
+ "NEEDLE-MODEL",
+ );
+
+ await user.clear(search);
+ await user.type(search, "absent");
+ expect(screen.queryAllByTestId(/^automation-/)).toHaveLength(0);
+ });
+
+ it("enables and disables automations while tracking only enablement", async () => {
+ const enabled = makeAutomation({ id: "enabled", enabled: true });
+ const disabled = makeAutomation({
+ id: "disabled",
+ name: "Disabled automation",
+ enabled: false,
+ });
+ mocks.automationsState.data = {
+ automations: [enabled, disabled],
+ total: 2,
+ };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(screen.getByRole("button", { name: "toggle-disabled" }));
+ await user.click(screen.getByRole("button", { name: "toggle-enabled" }));
+
+ expect(mocks.toggle).toHaveBeenNthCalledWith(1, {
+ id: "disabled",
+ enabled: true,
+ });
+ expect(mocks.toggle).toHaveBeenNthCalledWith(2, {
+ id: "enabled",
+ enabled: false,
+ });
+ expect(mocks.trackEnabled).toHaveBeenCalledOnce();
+ expect(mocks.trackEnabled).toHaveBeenCalledWith({
+ automationId: "disabled",
+ automationName: "Disabled automation",
+ });
+ });
+
+ it("keeps stale list actions defensive and identifies missing toggles", async () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 1,
+ };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", {
+ name: `stale-toggle-${I18nKey.AUTOMATIONS$ACTIVE}`,
+ }),
+ );
+ await user.click(
+ screen.getByRole("button", {
+ name: `stale-delete-${I18nKey.AUTOMATIONS$ACTIVE}`,
+ }),
+ );
+ await user.click(
+ screen.getByRole("button", {
+ name: `stale-edit-${I18nKey.AUTOMATIONS$ACTIVE}`,
+ }),
+ );
+
+ expect(mocks.toggle).toHaveBeenCalledWith({
+ id: "missing-id",
+ enabled: true,
+ });
+ expect(mocks.trackEnabled).toHaveBeenCalledWith({
+ automationId: "missing-id",
+ automationName: "missing-id",
+ });
+ expect(screen.queryByTestId("delete-modal")).not.toBeInTheDocument();
+ expect(screen.queryByTestId("edit-modal")).not.toBeInTheDocument();
+ });
+
+ it("reports pending dispatches and confirms a successful run", async () => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ mocks.dispatchState.isPending = true;
+ mocks.dispatchState.variables = automation.id;
+ mocks.dispatch.mockImplementation(
+ (_id: string, options: { onSuccess: () => void }) => options.onSuccess(),
+ );
+ const user = userEvent.setup();
+
+ renderList();
+ expect(
+ screen.getByTestId(`pending-${I18nKey.AUTOMATIONS$ACTIVE}`),
+ ).toHaveTextContent(automation.id);
+ expect(
+ screen.getByTestId(`pending-${I18nKey.AUTOMATIONS$INACTIVE}`),
+ ).toHaveTextContent(automation.id);
+ await user.click(
+ screen.getByRole("button", { name: `run-${automation.id}` }),
+ );
+
+ expect(mocks.dispatch).toHaveBeenCalledWith(
+ automation.id,
+ expect.objectContaining({
+ onSuccess: expect.any(Function),
+ onError: expect.any(Function),
+ }),
+ );
+ expect(mocks.successToast).toHaveBeenCalledWith(
+ I18nKey.AUTOMATIONS$RUN_NOW_SUCCESS,
+ );
+ });
+
+ it("uses no pending row when a dispatch has no id yet", () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 1,
+ };
+ mocks.dispatchState.isPending = true;
+
+ renderList();
+
+ expect(screen.getAllByText("none", { selector: "output" })).toHaveLength(2);
+ });
+
+ it.each([
+ {
+ label: "the backend response message",
+ error: Object.assign(new Error("axios fallback"), {
+ isAxiosError: true,
+ response: { data: { message: "backend rejected dispatch" } },
+ }),
+ expected: "backend rejected dispatch",
+ },
+ {
+ label: "the Axios message",
+ error: Object.assign(new Error("network failed"), {
+ isAxiosError: true,
+ }),
+ expected: "network failed",
+ },
+ {
+ label: "the translated Axios fallback",
+ error: Object.assign(new Error(""), { isAxiosError: true }),
+ expected: I18nKey.AUTOMATIONS$RUN_NOW_ERROR,
+ },
+ {
+ label: "a plain error message",
+ error: new Error("plain failure"),
+ expected: "plain failure",
+ },
+ {
+ label: "the translated plain-error fallback",
+ error: new Error(""),
+ expected: I18nKey.AUTOMATIONS$RUN_NOW_ERROR,
+ },
+ ])("surfaces $label when a run fails", async ({ error, expected }) => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ mocks.dispatch.mockImplementation(
+ (_id: string, options: { onError: (dispatchError: unknown) => void }) =>
+ options.onError(error),
+ );
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: `run-${automation.id}` }),
+ );
+
+ expect(mocks.errorToast).toHaveBeenCalledWith(expected);
+ });
+
+ it("deletes the selected automation after confirmation", async () => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: `delete-${automation.id}` }),
+ );
+ expect(screen.getByTestId("delete-modal")).toHaveTextContent(
+ automation.name,
+ );
+ await user.click(screen.getByRole("button", { name: "confirm-delete" }));
+
+ expect(mocks.remove).toHaveBeenCalledWith(automation.id);
+ expect(screen.queryByTestId("delete-modal")).not.toBeInTheDocument();
+ });
+
+ it("lets the user cancel deletion", async () => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: `delete-${automation.id}` }),
+ );
+ await user.click(screen.getByRole("button", { name: "cancel-delete" }));
+
+ expect(mocks.remove).not.toHaveBeenCalled();
+ expect(screen.queryByTestId("delete-modal")).not.toBeInTheDocument();
+ });
+
+ it("opens and closes editing for local automations", async () => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: `edit-${automation.id}` }),
+ );
+ expect(screen.getByTestId("edit-modal")).toHaveTextContent(automation.name);
+ await user.click(screen.getByRole("button", { name: "close-edit" }));
+
+ expect(screen.queryByTestId("edit-modal")).not.toBeInTheDocument();
+ });
+
+ it("offers editing regardless of the backend kind", () => {
+ const automation = makeAutomation();
+ mocks.backendKind = "cloud";
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+
+ renderList();
+
+ expect(
+ screen.getByRole("button", { name: `edit-${automation.id}` }),
+ ).toBeInTheDocument();
+ });
+
+ it("downloads an exported automation and records the backend kind", async () => {
+ const automation = makeAutomation();
+ mocks.automationsState.data = { automations: [automation], total: 1 };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: `export-${automation.id}` }),
+ );
+
+ expect(mocks.serializeAutomation).toHaveBeenCalledWith(automation);
+ expect(mocks.exportFilename).toHaveBeenCalledWith(automation);
+ expect(mocks.downloadBlob).toHaveBeenCalledWith(
+ expect.any(Blob),
+ "daily-digest.automation.json",
+ );
+ const blob = mocks.downloadBlob.mock.calls[0][0] as Blob;
+ expect(blob.type).toBe("application/json");
+ expect(await readBlobText(blob)).toBe(
+ `${JSON.stringify(mocks.serializeAutomation.mock.results[0].value, null, 2)}\n`,
+ );
+ expect(mocks.trackExported).toHaveBeenCalledWith({ backendKind: "local" });
+ });
+
+ it("hides create and import actions without management permission", () => {
+ mocks.canManage = false;
+ render(<AutomationsList />);
+ expect(
+ screen.queryByTestId("automations-add-automation"),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId("automations-import-automation"),
+ ).not.toBeInTheDocument();
+ expect(screen.queryByTestId("add-modal")).not.toBeInTheDocument();
+ expect(screen.queryByTestId("import-modal")).not.toBeInTheDocument();
+ });
+
+ it("opens and closes the add-automation form", async () => {
+ const user = userEvent.setup();
+ renderList();
+
+ expect(screen.queryByTestId("add-modal")).not.toBeInTheDocument();
+ await user.click(screen.getByTestId("automations-add-automation"));
+ expect(screen.getByTestId("add-modal")).toBeInTheDocument();
+ await user.click(screen.getByRole("button", { name: "close-add" }));
+
+ expect(screen.queryByTestId("add-modal")).not.toBeInTheDocument();
+ });
+
+ it("opens the import modal from the import action", async () => {
+ const user = userEvent.setup();
+ renderList();
+
+ expect(screen.queryByTestId("import-modal")).not.toBeInTheDocument();
+ await user.click(screen.getByTestId("automations-import-automation"));
+
+ expect(screen.getByTestId("import-modal")).toBeInTheDocument();
+ expect(screen.getByTestId("automations-import-file")).toBeInTheDocument();
+ });
+
+ it("rejects malformed JSON before validating an import", async () => {
+ renderList();
+ uploadFile("not json");
+
+ await waitFor(() => {
+ expect(mocks.errorToast).toHaveBeenCalledWith(
+ I18nKey.AUTOMATIONS$IMPORT_INVALID_JSON,
+ );
+ });
+ expect(mocks.parseAutomationFile).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ { error: new Error("invalid automation"), expected: "invalid automation" },
+ { error: "unknown validation failure", expected: I18nKey.ERROR$GENERIC },
+ ])("surfaces import validation failures", async ({ error, expected }) => {
+ mocks.parseAutomationFile.mockImplementation(() => {
+ throw error;
+ });
+ renderList();
+
+ uploadFile("{}");
+
+ await waitFor(() => {
+ expect(mocks.errorToast).toHaveBeenCalledWith(expected);
+ });
+ });
+
+ it("previews a valid import and lets the user close it", async () => {
+ const spec = makeImportSpec({ name: "Preview me" });
+ mocks.parseAutomationFile.mockReturnValue(spec);
+ const user = userEvent.setup();
+ renderList();
+
+ uploadFile("{}");
+ expect(await screen.findByTestId("import-modal")).toHaveTextContent(
+ "Preview me",
+ );
+ await user.click(screen.getByRole("button", { name: "close-import" }));
+
+ expect(screen.queryByTestId("import-modal")).not.toBeInTheDocument();
+ });
+
+ it("imports a preview as disabled and links to the created automation", async () => {
+ const spec = makeImportSpec({ name: "Preview me" });
+ mocks.parseAutomationFile.mockReturnValue(spec);
+ mocks.importState.isPending = true;
+ mocks.importAutomation.mockImplementation(
+ (
+ _spec: AutomationSpec,
+ options: { onSuccess: (created: Automation) => void },
+ ) =>
+ options.onSuccess(
+ makeAutomation({ id: "created/id", name: "Created automation" }),
+ ),
+ );
+ const user = userEvent.setup();
+ renderList();
+
+ uploadFile("{}");
+ const modal = await screen.findByTestId("import-modal");
+ expect(modal).toHaveAttribute("data-importing", "true");
+ await user.click(screen.getByRole("button", { name: "confirm-import" }));
+
+ expect(mocks.importAutomation).toHaveBeenCalledWith(
+ { ...spec, enabled: false },
+ expect.objectContaining({
+ onSuccess: expect.any(Function),
+ onError: expect.any(Function),
+ }),
+ );
+ expect(mocks.successToastWithLink).toHaveBeenCalledWith(
+ I18nKey.AUTOMATIONS$IMPORT_SUCCESS,
+ I18nKey.AUTOMATIONS$IMPORT_VIEW,
+ "/automations/created%2Fid",
+ );
+ expect(mocks.translate).toHaveBeenCalledWith(
+ I18nKey.AUTOMATIONS$IMPORT_SUCCESS,
+ { name: "Created automation" },
+ );
+ expect(screen.queryByTestId("import-modal")).not.toBeInTheDocument();
+ });
+
+ it.each([
+ {
+ label: "a backend detail",
+ error: Object.assign(new Error("axios fallback"), {
+ isAxiosError: true,
+ response: { data: { detail: "duplicate automation" } },
+ }),
+ expected: "duplicate automation",
+ },
+ {
+ label: "an Axios message when detail is structured",
+ error: Object.assign(new Error("request failed"), {
+ isAxiosError: true,
+ response: { data: { detail: { code: "duplicate" } } },
+ }),
+ expected: "request failed",
+ },
+ {
+ label: "an Axios message when no response arrived",
+ error: Object.assign(new Error("network failed"), {
+ isAxiosError: true,
+ }),
+ expected: "network failed",
+ },
+ {
+ label: "a non-Axios error message",
+ error: new Error("hidden implementation detail"),
+ expected: "hidden implementation detail",
+ },
+ ])("surfaces $label when import fails", async ({ error, expected }) => {
+ mocks.importAutomation.mockImplementation(
+ (
+ _spec: AutomationSpec,
+ options: { onError: (importError: unknown) => void },
+ ) => options.onError(error),
+ );
+ const user = userEvent.setup();
+ renderList();
+
+ uploadFile("{}");
+ await user.click(
+ await screen.findByRole("button", { name: "confirm-import" }),
+ );
+
+ expect(mocks.errorToast).toHaveBeenCalledWith(expected);
+ });
+
+ it("persists view changes", async () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 1,
+ };
+ window.localStorage.setItem("openhands-automations-view", "list");
+ const user = userEvent.setup();
+
+ renderList();
+ expect(screen.getByTestId("view-toggle")).toHaveTextContent("list");
+ await user.click(screen.getByTestId("view-toggle"));
+
+ expect(screen.getByTestId("view-toggle")).toHaveTextContent("grid");
+ expect(window.localStorage.getItem("openhands-automations-view")).toBe(
+ "grid",
+ );
+ });
+
+ it("loads the next page size while more automations remain", async () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 51,
+ };
+ const user = userEvent.setup();
+
+ renderList();
+ await user.click(
+ screen.getByRole("button", { name: I18nKey.AUTOMATIONS$LOAD_MORE }),
+ );
+
+ expect(mocks.useAutomations).toHaveBeenLastCalledWith({
+ limit: 100,
+ offset: 0,
+ enabled: true,
+ });
+ });
+
+ it("does not offer another page when the total is already displayed", () => {
+ mocks.automationsState.data = {
+ automations: [makeAutomation()],
+ total: 1,
+ };
+
+ renderList();
+
+ expect(
+ screen.queryByRole("button", { name: I18nKey.AUTOMATIONS$LOAD_MORE }),
+ ).not.toBeInTheDocument();
+ });
+});