@truedat/ai 8.14.2 → 8.14.3

package/src/components/providers/__tests__/ProviderEditor.spec.js

@@ -3,6 +3,29 @@ import { waitFor } from "@testing-library/react";
 import { render, waitForLoad } from "@truedat/test/render";
 import ProviderEditor from "../ProviderEditor";
 
+jest.mock("@truedat/ai/hooks/useIndices", () => ({
+  useIndices: () => ({ data: [], loading: false, mutate: jest.fn() }),
+  useIndexCreate: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexDelete: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexEnable: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexDisable: () => ({ trigger: jest.fn(), isMutating: false }),
+}));
+
+const mockEnable = jest.fn();
+const mockDisable = jest.fn();
+let mockEnabling = false;
+
+jest.mock("@truedat/ai/hooks/useProviders", () => ({
+  useProviderEnable: () => ({
+    trigger: (...a) => mockEnable(...a),
+    isMutating: mockEnabling,
+  }),
+  useProviderDisable: () => ({
+    trigger: (...a) => mockDisable(...a),
+    isMutating: false,
+  }),
+}));
+
 jest.mock("@truedat/core/hooks", () => ({
   useLocales: jest.fn(() => ({
     loading: false,
@@ -171,6 +194,196 @@ describe("<ProviderEditor />", () => {
   });
 });
 
+describe("<ProviderEditor /> enabled provider", () => {
+  const ENABLED_AT = "2026-10-29T10:00:00Z";
+  const saved = { ...props.selectedProvider, enabled_at: null, agents: null };
+  const renderEditor = async (selectedProvider, extra = {}) => {
+    const onSubmit = jest.fn();
+    const onRefresh = jest.fn();
+    const rendered = render(
+      <ProviderEditor
+        {...props}
+        {...{
+          selectedProvider,
+          onSubmit,
+          onRefresh,
+          providers: [selectedProvider],
+        }}
+        {...extra}
+      />,
+      renderOpts,
+    );
+    await waitForLoad(rendered);
+    return { ...rendered, onSubmit, onRefresh };
+  };
+  const toggle = (r) => r.container.querySelector('input[type="checkbox"]');
+
+  beforeEach(() => {
+    mockEnable.mockReset().mockResolvedValue({});
+    mockDisable.mockReset().mockResolvedValue({});
+    mockEnabling = false;
+  });
+
+  it("has no role dropdown and no default checkbox", async () => {
+    const r = await renderEditor(saved);
+    expect(r.queryByText("providers.form.agents")).not.toBeInTheDocument();
+    expect(r.queryByText("providers.form.default")).not.toBeInTheDocument();
+  });
+
+  it("shows the toggle with the hint behind a ? icon (12-4)", async () => {
+    const r = await renderEditor(saved);
+    const user = userEvent.setup({ delay: null });
+    expect(r.getByText("providers.form.enabled")).toBeVisible();
+    expect(r.queryByText("providers.form.enabled.hint")).toBeNull();
+    await user.hover(r.getByTestId("help-provider-enabled"));
+    expect(await r.findByText("providers.form.enabled.hint")).toBeVisible();
+    expect(toggle(r)).not.toBeChecked();
+  });
+
+  it("offers the toggle on a new provider, off when others exist", async () => {
+    const draft = { name: "", type: "openai", properties: {} };
+    const r = await renderEditor(draft, { providers: [saved] });
+    expect(r.getByText("providers.form.enabled")).toBeVisible();
+    expect(toggle(r)).not.toBeChecked();
+  });
+
+  it("starts on for the first provider ever created", async () => {
+    const draft = { name: "", type: "openai", properties: {} };
+    const r = await renderEditor(draft, { providers: [] });
+    expect(toggle(r)).toBeChecked();
+  });
+
+  it("passes the enable choice to onSubmit when creating", async () => {
+    const draft = {
+      name: "new",
+      type: "openai",
+      properties: { model: "m", organization_key: "o" },
+    };
+    const r = await renderEditor(draft, { providers: [saved] });
+    const user = userEvent.setup({ delay: null });
+    await user.click(r.getByText("providers.form.enabled"));
+    expect(toggle(r)).toBeChecked();
+    expect(mockEnable).not.toHaveBeenCalled();
+    await user.type(r.getAllByRole("textbox")[0], "x");
+    await user.click(r.getByRole("button", { name: /save/i }));
+    await waitFor(() => expect(r.onSubmit).toHaveBeenCalled());
+    expect(r.onSubmit.mock.calls[0][1]).toEqual({ enable: true });
+  });
+
+  it("reads the toggle from the refreshed list, not from selectedProvider (12-5)", async () => {
+    const r = await renderEditor(saved, {
+      providers: [{ ...saved, enabled_at: ENABLED_AT }],
+    });
+    expect(toggle(r)).toBeChecked();
+  });
+
+  it("enables at once without marking the form dirty (12-4, 12-5)", async () => {
+    const r = await renderEditor(saved);
+    const user = userEvent.setup({ delay: null });
+    await user.click(r.getByText("providers.form.enabled"));
+    await waitFor(() => expect(mockEnable).toHaveBeenCalledWith({ id: 1 }));
+    await waitFor(() => expect(r.onRefresh).toHaveBeenCalled());
+    expect(mockDisable).not.toHaveBeenCalled();
+    expect(r.getByRole("button", { name: /save/i })).toBeDisabled();
+  });
+
+  it("asks for confirmation before disabling (12-5)", async () => {
+    const r = await renderEditor({ ...saved, enabled_at: ENABLED_AT });
+    const user = userEvent.setup({ delay: null });
+    expect(toggle(r)).toBeChecked();
+    await user.click(r.getByText("providers.form.enabled"));
+    expect(
+      r.getByText("providers.enabled.disable.confirm.header"),
+    ).toBeVisible();
+    expect(
+      r.getByText("providers.enabled.disable.confirm.content"),
+    ).toBeVisible();
+    expect(mockDisable).not.toHaveBeenCalled();
+    await user.click(r.getByRole("button", { name: /modal-negative-action/i }));
+    expect(mockDisable).not.toHaveBeenCalled();
+    await user.click(r.getByText("providers.form.enabled"));
+    await user.click(
+      r.getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+    await waitFor(() => expect(mockDisable).toHaveBeenCalledWith({ id: 1 }));
+    await waitFor(() => expect(r.onRefresh).toHaveBeenCalled());
+  });
+
+  it("shows a server error in the editor (12-5)", async () => {
+    mockEnable.mockRejectedValue({
+      response: { data: { errors: { enabled_at: ["already taken"] } } },
+    });
+    const r = await renderEditor(saved);
+    const user = userEvent.setup({ delay: null });
+    await user.click(r.getByText("providers.form.enabled"));
+    expect(await r.findByText("already taken")).toBeVisible();
+    expect(r.onRefresh).toHaveBeenCalled();
+  });
+
+  it("lets the editor server error be dismissed", async () => {
+    mockEnable.mockRejectedValue({
+      response: { data: { errors: { enabled_at: ["already taken"] } } },
+    });
+    const r = await renderEditor(saved);
+    const user = userEvent.setup({ delay: null });
+    await user.click(r.getByText("providers.form.enabled"));
+    expect(await r.findByText("already taken")).toBeVisible();
+    await user.click(r.container.querySelector(".message .close.icon"));
+    expect(r.queryByText("already taken")).not.toBeInTheDocument();
+  });
+
+  it("keeps the toggle disabled until the refresh has landed (12-5)", async () => {
+    let finishRefresh;
+    const onRefresh = jest.fn(
+      () => new Promise((resolve) => (finishRefresh = resolve)),
+    );
+    const r = await renderEditor(saved, { onRefresh });
+    const user = userEvent.setup({ delay: null });
+    await user.click(r.getByText("providers.form.enabled"));
+    await waitFor(() => expect(onRefresh).toHaveBeenCalled());
+    expect(toggle(r)).toBeDisabled();
+    finishRefresh();
+    await waitFor(() => expect(toggle(r)).toBeEnabled());
+  });
+
+  it("disables the toggle while a request is in flight (12-5)", async () => {
+    mockEnabling = true;
+    const r = await renderEditor(saved);
+    expect(toggle(r)).toBeDisabled();
+  });
+
+  it("sends no is_default, agents, enabled or enabled_at on save (12-7, 12-10)", async () => {
+    const r = await renderEditor({
+      ...saved,
+      enabled_at: ENABLED_AT,
+      agents: "fast",
+      is_default: true,
+      enabled: true,
+    });
+    const user = userEvent.setup({ delay: null });
+    await user.type(r.getAllByRole("textbox")[0], "x");
+    const save = r.getByRole("button", { name: /save/i });
+    await waitFor(() => expect(save).toBeEnabled());
+    await user.click(save);
+    await waitFor(() => expect(r.onSubmit).toHaveBeenCalled());
+    const payload = r.onSubmit.mock.calls[0][0];
+    for (const key of ["is_default", "agents", "enabled", "enabled_at"]) {
+      expect(payload).not.toHaveProperty(key);
+    }
+    expect(payload.name).toBe("provider1x");
+  });
+
+  it("shows embedding models only for saved providers", async () => {
+    const r = await renderEditor(saved);
+    expect(r.getByText("providers.embeddingModels.title")).toBeVisible();
+    r.unmount();
+    const n = await renderEditor({ name: "", type: "openai", properties: {} });
+    expect(
+      n.queryByText("providers.embeddingModels.title"),
+    ).not.toBeInTheDocument();
+  });
+});
+
 describe("<ProviderEditor /> LLM gateway", () => {
   const gatewayRenderOpts = {
     ...renderOpts,
@@ -288,7 +501,6 @@ describe("<ProviderEditor /> LLM gateway", () => {
     expect(rendered.onSubmit.mock.calls[0][0]).toEqual({
       name: "Company models",
       type: "llm_gateway",
-      agents: undefined,
       properties: {
         base_url: values[0],
         model: values[1],

package/src/components/providers/__tests__/Providers.spec.js

@@ -1,7 +1,23 @@
+import userEvent from "@testing-library/user-event";
 import { waitFor } from "@testing-library/react";
 import { renderWithIntl as render } from "@truedat/test/renderWithIntl";
 import Providers from "../Providers";
 
+let mockIndices = [];
+
+jest.mock("@truedat/ai/hooks/useIndices", () => ({
+  useIndices: () => ({ data: mockIndices, loading: false, mutate: jest.fn() }),
+  useIndexCreate: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexDelete: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexEnable: () => ({ trigger: jest.fn(), isMutating: false }),
+  useIndexDisable: () => ({ trigger: jest.fn(), isMutating: false }),
+}));
+
+const mockDeleteTrigger = jest.fn();
+const mockCreateTrigger = jest.fn();
+const mockEnableTrigger = jest.fn();
+let mockProviders;
+
 jest.mock("@truedat/ai/hooks/useProviders", () => {
   const originalModule = jest.requireActual("@truedat/ai/hooks/useProviders");
 
@@ -9,24 +25,24 @@ jest.mock("@truedat/ai/hooks/useProviders", () => {
     __esModule: true,
     ...originalModule,
     useProviders: jest.fn(() => ({
-      data: {
-        data: [
-          {
-            name: "rm1",
-            resource_type: "boolean",
-            fields: [{ source: "s1", target: "t1" }],
-            selector: { system_external_id: 1 },
-          },
-        ],
-      },
+      data: { data: mockProviders },
       loading: false,
+      mutate: jest.fn(),
     })),
     useProviderCreate: jest.fn(() => ({
-      trigger: jest.fn(() => new Promise(() => {})),
+      trigger: (...a) => mockCreateTrigger(...a),
       isMutating: false,
     })),
     useProviderDelete: jest.fn(() => ({
-      trigger: jest.fn(() => new Promise(() => {})),
+      trigger: (...a) => mockDeleteTrigger(...a),
+      isMutating: false,
+    })),
+    useProviderEnable: jest.fn(() => ({
+      trigger: (...a) => mockEnableTrigger(...a),
+      isMutating: false,
+    })),
+    useProviderDisable: jest.fn(() => ({
+      trigger: jest.fn(),
       isMutating: false,
     })),
     useProviderUpdate: jest.fn(() => ({
@@ -36,7 +52,89 @@ jest.mock("@truedat/ai/hooks/useProviders", () => {
   };
 });
 
+const baseProviders = () => [
+  {
+    id: 1,
+    name: "rm1",
+    type: "openai",
+    enabled_at: null,
+    agents: null,
+    properties: {},
+  },
+];
+
 describe("<Providers />", () => {
+  beforeEach(() => {
+    jest.useRealTimers();
+    mockProviders = baseProviders();
+    mockIndices = [];
+    mockDeleteTrigger.mockReset();
+    mockCreateTrigger.mockReset();
+    mockEnableTrigger.mockReset().mockResolvedValue({});
+  });
+
+  describe("creating a provider", () => {
+    const create = async (enabledAt) => {
+      mockCreateTrigger.mockResolvedValue({
+        data: { data: { id: 7, enabled_at: enabledAt } },
+      });
+      const user = userEvent.setup({ delay: null });
+      const r = render(<Providers />, {});
+      await user.click(r.getByText("providers.action.new"));
+      await user.type(r.getByPlaceholderText("providers.form.name"), "p");
+      return { user, r };
+    };
+
+    it("enables the new provider when the toggle is on (follow-up)", async () => {
+      const { user, r } = await create(null);
+      await user.click(r.getByText("providers.form.enabled"));
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.model"),
+        "m",
+      );
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.organizationKey"),
+        "o",
+      );
+      await user.click(r.getByRole("button", { name: "actions.save" }));
+      await waitFor(() => expect(mockCreateTrigger).toHaveBeenCalled());
+      await waitFor(() =>
+        expect(mockEnableTrigger).toHaveBeenCalledWith({ id: 7 }),
+      );
+    });
+
+    it("does not enable it when the toggle is off", async () => {
+      const { user, r } = await create(null);
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.model"),
+        "m",
+      );
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.organizationKey"),
+        "o",
+      );
+      await user.click(r.getByRole("button", { name: "actions.save" }));
+      await waitFor(() => expect(mockCreateTrigger).toHaveBeenCalled());
+      expect(mockEnableTrigger).not.toHaveBeenCalled();
+    });
+
+    it("does not enable twice when td-ai already enabled it", async () => {
+      mockProviders = [];
+      const { user, r } = await create("2026-10-29T10:00:00Z");
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.model"),
+        "m",
+      );
+      await user.type(
+        r.getByPlaceholderText("providerProperties.form.organizationKey"),
+        "o",
+      );
+      await user.click(r.getByRole("button", { name: "actions.save" }));
+      await waitFor(() => expect(mockCreateTrigger).toHaveBeenCalled());
+      expect(mockEnableTrigger).not.toHaveBeenCalled();
+    });
+  });
+
   const renderOpts = {
     messages: {
       en: {
@@ -72,4 +170,145 @@ describe("<Providers />", () => {
     await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
     expect(container).toMatchSnapshot();
   });
+
+  it("shows the banner when providers exist and none is enabled (12-3)", () => {
+    const { getByText } = render(<Providers />, {});
+    expect(getByText("providers.enabled.banner")).toBeVisible();
+  });
+
+  it("hides the banner and badges only the enabled provider (12-1, 12-3)", () => {
+    mockProviders = [
+      {
+        ...baseProviders()[0],
+        enabled_at: "2026-10-29T10:00:00Z",
+        agents: "fast",
+      },
+      { ...baseProviders()[0], id: 2, name: "rm2" },
+    ];
+    const { queryByText, getAllByText } = render(<Providers />, {});
+    expect(queryByText("providers.enabled.banner")).not.toBeInTheDocument();
+    expect(getAllByText("providers.enabled.badge")).toHaveLength(1);
+    expect(queryByText("providers.default.badge")).not.toBeInTheDocument();
+  });
+
+  it("does not show the banner without providers (12-3)", () => {
+    mockProviders = [];
+    const { queryByText } = render(<Providers />, {});
+    expect(queryByText("providers.enabled.banner")).not.toBeInTheDocument();
+  });
+
+  it("shows the count of enabled embedding models per provider (12-2)", () => {
+    mockProviders = [
+      baseProviders()[0],
+      { ...baseProviders()[0], id: 2, name: "rm2" },
+      { ...baseProviders()[0], id: 3, name: "rm3", type: "anthropic" },
+    ];
+    mockIndices = [
+      { id: 1, provider: 1, enabled_at: "2026-10-29T10:00:00Z" },
+      { id: 2, provider: 1, enabled_at: "2026-10-29T10:00:00Z" },
+      { id: 3, provider: 1, enabled_at: null },
+      { id: 4, provider: 2, enabled_at: null },
+      { id: 5, provider: 3, enabled_at: "2026-10-29T10:00:00Z" },
+    ];
+    const { getAllByText, getByText } = render(<Providers />, {});
+    const labels = getAllByText("providers.embeddingModels.enabledCount");
+    expect(labels).toHaveLength(1);
+    expect(labels[0].closest(".item")).toHaveTextContent("rm1");
+    expect(labels[0]).toHaveClass("label");
+    expect(getByText("rm2").closest(".item")).not.toHaveTextContent(
+      "enabledCount",
+    );
+  });
+
+  it("keeps the provider and shows the server error when deleting an enabled one (12-8)", async () => {
+    mockProviders = [
+      { ...baseProviders()[0], enabled_at: "2026-10-29T10:00:00Z" },
+    ];
+    mockDeleteTrigger.mockRejectedValue({
+      response: {
+        data: { errors: { enabled_at: ["disable it first"] } },
+      },
+    });
+    const user = userEvent.setup({ delay: null });
+    const { getByText, getByRole, findByText } = render(<Providers />, {});
+    await user.click(getByText("rm1"));
+    await user.click(getByRole("button", { name: "actions.delete" }));
+    await user.click(
+      getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+    expect(await findByText("disable it first")).toBeVisible();
+    expect(getByRole("button", { name: "actions.save" })).toBeInTheDocument();
+  });
+
+  it("shows the models error and keeps the provider when delete fails (06-8)", async () => {
+    mockProviders = [{ ...baseProviders()[0], enabled_at: null }];
+    mockDeleteTrigger.mockRejectedValue({
+      response: {
+        data: { errors: { indices: ["provider has embedding models"] } },
+      },
+    });
+    const user = userEvent.setup({ delay: null });
+    const { getByText, getByRole, findByText } = render(<Providers />, {});
+    await user.click(getByText("rm1"));
+    await user.click(getByRole("button", { name: "actions.delete" }));
+    await user.click(
+      getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+    expect(
+      await findByText("providers.embeddingModels.error.providerHasModels"),
+    ).toBeVisible();
+    expect(getByRole("button", { name: "actions.save" })).toBeInTheDocument();
+  });
+
+  it("drops the delete error when another provider is selected", async () => {
+    mockProviders = [
+      { ...baseProviders()[0], enabled_at: null },
+      { ...baseProviders()[0], id: 2, name: "rm2", enabled_at: null },
+    ];
+    mockDeleteTrigger.mockRejectedValue({
+      response: {
+        data: { errors: { indices: ["provider has embedding models"] } },
+      },
+    });
+    const user = userEvent.setup({ delay: null });
+    const { getByText, getByRole, findByText, queryByText } = render(
+      <Providers />,
+      {},
+    );
+    await user.click(getByText("rm1"));
+    await user.click(getByRole("button", { name: "actions.delete" }));
+    await user.click(
+      getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+    await findByText("providers.embeddingModels.error.providerHasModels");
+    await user.click(getByText("rm2"));
+    expect(
+      queryByText("providers.embeddingModels.error.providerHasModels"),
+    ).not.toBeInTheDocument();
+  });
+
+  it("lets the delete error be dismissed", async () => {
+    mockProviders = [{ ...baseProviders()[0], enabled_at: null }];
+    mockDeleteTrigger.mockRejectedValue({
+      response: {
+        data: { errors: { indices: ["provider has embedding models"] } },
+      },
+    });
+    const user = userEvent.setup({ delay: null });
+    const { getByText, getByRole, findByText, queryByText, container } = render(
+      <Providers />,
+      {},
+    );
+    await user.click(getByText("rm1"));
+    await user.click(getByRole("button", { name: "actions.delete" }));
+    await user.click(
+      getByRole("button", { name: /modal-affirmative-action/i }),
+    );
+    await findByText("providers.embeddingModels.error.providerHasModels");
+    await user.click(container.querySelector(".message .close.icon"));
+    expect(
+      queryByText("providers.embeddingModels.error.providerHasModels"),
+    ).not.toBeInTheDocument();
+    expect(getByRole("button", { name: "actions.save" })).toBeInTheDocument();
+  });
 });