OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
/**
* Tests for useUpdateSettingsMutation: POSTs /api/settings, invalidates the
* settings cache, and refetches the current provider's model list. The hook
* mounts useGetCurrentProviderModelsQuery internally, so /api/settings (GET)
* and the relevant /api/models/* endpoint must both be mocked even though
* this file is only testing the mutation.
*/
import { act, renderHook, waitFor } from "@testing-library/react";
import { HttpResponse, http } from "msw";
import { describe, expect, it } from "vitest";
import { server } from "@/test-utils/msw/server";
import { createQueryWrapper } from "@/test-utils/render";
import { useGetModelCatalogQuery } from "../queries/useGetModelsQuery";
import {
isEmbeddingProviderInUseError,
useUpdateSettingsMutation,
} from "./useUpdateSettingsMutation";
describe("useUpdateSettingsMutation", () => {
it("posts the settings payload and triggers a settings refetch on success", async () => {
let settingsFetchCount = 0;
let capturedBody: unknown;
server.use(
http.get("/api/settings", () => {
settingsFetchCount += 1;
return HttpResponse.json({ agent: { llm_provider: "openai" } });
}),
http.post("/api/settings", async ({ request }) => {
capturedBody = await request.json();
return HttpResponse.json({
message: "saved",
settings: { agent: { llm_provider: "openai" } },
});
}),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
);
const { result } = renderHook(() => useUpdateSettingsMutation(), {
wrapper: createQueryWrapper(),
});
await waitFor(() => expect(settingsFetchCount).toBe(1));
act(() => result.current.mutate({ llm_model: "gpt-5.4" }));
await waitFor(() => expect(result.current.isSuccess).toBe(true));
expect(capturedBody).toEqual({ llm_model: "gpt-5.4" });
// invalidateQueries refetches the mounted useGetSettingsQuery observer.
await waitFor(() => expect(settingsFetchCount).toBe(2));
});
it("refreshes the model catalogue so pickers see a re-configured cluster's models", async () => {
// Settings → Providers saves credentials only; the Agent and Ingestion
// pickers read the catalogue, which lists a cluster with saved credentials.
let catalogFetchCount = 0;
server.use(
http.get("/api/settings", () => HttpResponse.json({})),
http.post("/api/settings", () =>
HttpResponse.json({ message: "saved", settings: {} }),
),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
http.get("/api/models/catalog", () => {
catalogFetchCount += 1;
const model =
catalogFetchCount === 1 ? "granite-3.3-2b-instruct" : "gpt-oss-120b";
return HttpResponse.json({
providers: [
{
key: "rhoai",
name: "Red Hat OpenShift AI",
credential_fields: [],
model_placeholder: null,
models: [{ model, mode: "chat" }],
embedding_models: [],
},
],
});
}),
);
const { result } = renderHook(
() => ({
catalog: useGetModelCatalogQuery(),
mutation: useUpdateSettingsMutation(),
}),
{ wrapper: createQueryWrapper() },
);
await waitFor(() =>
expect(result.current.catalog.data?.providers[0].models[0].model).toBe(
"granite-3.3-2b-instruct",
),
);
act(() =>
result.current.mutation.mutate({
provider_credentials: { rhoai: { api_key: "token" } },
}),
);
await waitFor(() =>
expect(result.current.catalog.data?.providers[0].models[0].model).toBe(
"gpt-oss-120b",
),
);
});
it("refetches the catalogue when its first load was still in flight during the save", async () => {
let catalogFetchCount = 0;
let releaseFirstLoad: () => void = () => {};
const firstLoadHeld = new Promise<void>((resolve) => {
releaseFirstLoad = resolve;
});
const catalogWith = (model: string) => ({
providers: [
{
key: "rhoai",
name: "Red Hat OpenShift AI",
credential_fields: [],
model_placeholder: null,
models: [{ model, mode: "chat" }],
embedding_models: [],
},
],
});
server.use(
http.get("/api/settings", () => HttpResponse.json({})),
http.post("/api/settings", () =>
HttpResponse.json({ message: "saved", settings: {} }),
),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
http.get("/api/models/catalog", async () => {
catalogFetchCount += 1;
// The first load started before the save, so it lists the old models.
if (catalogFetchCount === 1) {
await firstLoadHeld;
return HttpResponse.json(catalogWith("granite-3.3-2b-instruct"));
}
return HttpResponse.json(catalogWith("gpt-oss-120b"));
}),
);
const { result } = renderHook(
() => ({
catalog: useGetModelCatalogQuery(),
mutation: useUpdateSettingsMutation(),
}),
{ wrapper: createQueryWrapper() },
);
try {
await waitFor(() => expect(catalogFetchCount).toBe(1));
act(() =>
result.current.mutation.mutate({
provider_credentials: { rhoai: { api_key: "token" } },
}),
);
await waitFor(() => expect(result.current.mutation.isSuccess).toBe(true));
await waitFor(() => expect(catalogFetchCount).toBe(2));
} finally {
releaseFirstLoad();
}
await waitFor(() =>
expect(result.current.catalog.data?.providers[0].models[0].model).toBe(
"gpt-oss-120b",
),
);
expect(result.current.catalog.isFetching).toBe(false);
});
it("calls the caller's onSuccess in addition to the hook's own side effects", async () => {
server.use(
http.get("/api/settings", () => HttpResponse.json({})),
http.post("/api/settings", () =>
HttpResponse.json({ message: "saved", settings: {} }),
),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
);
let onSuccessCalled = false;
const { result } = renderHook(
() =>
useUpdateSettingsMutation({
onSuccess: () => {
onSuccessCalled = true;
},
}),
{ wrapper: createQueryWrapper() },
);
act(() => result.current.mutate({}));
await waitFor(() => expect(result.current.isSuccess).toBe(true));
expect(onSuccessCalled).toBe(true);
});
it("throws an UpdateSettingsError carrying the structured 409 payload", async () => {
server.use(
http.get("/api/settings", () => HttpResponse.json({})),
http.post("/api/settings", () =>
HttpResponse.json(
{
error: "Embedding provider still in use",
code: "embedding_provider_in_use",
affected_provider: "openai",
affected_models: [
{ model: "text-embedding-3-small", doc_count: 4 },
],
},
{ status: 409 },
),
),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
);
const { result } = renderHook(() => useUpdateSettingsMutation(), {
wrapper: createQueryWrapper(),
});
act(() => result.current.mutate({ remove_openai_config: true }));
await waitFor(() => expect(result.current.isError).toBe(true));
expect(isEmbeddingProviderInUseError(result.current.error)).toBe(true);
if (isEmbeddingProviderInUseError(result.current.error)) {
expect(result.current.error.affectedProvider).toBe("openai");
expect(result.current.error.affectedModels).toEqual([
{ model: "text-embedding-3-small", doc_count: 4 },
]);
}
});
it("does not classify a plain 500 as the embedding-provider-in-use error", async () => {
server.use(
http.get("/api/settings", () => HttpResponse.json({})),
http.post("/api/settings", () =>
HttpResponse.json({ error: "database unavailable" }, { status: 500 }),
),
http.post("/api/models/openai", () =>
HttpResponse.json({ language_models: [], embedding_models: [] }),
),
);
const { result } = renderHook(() => useUpdateSettingsMutation(), {
wrapper: createQueryWrapper(),
});
act(() => result.current.mutate({}));
await waitFor(() => expect(result.current.isError).toBe(true));
expect(isEmbeddingProviderInUseError(result.current.error)).toBe(false);
expect(result.current.error?.message).toBe("database unavailable");
});
});