OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
import { act, fireEvent } from "@testing-library/react";
import { HttpResponse, http } from "msw";
import { useEffect } from "react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useKnowledgeFilter } from "@/contexts/knowledge-filter-context";
import { toLocalDayStartISOString } from "@/lib/time-utils";
import { authPresets, withAuth } from "@/test-utils/fixtures/auth";
import { server } from "@/test-utils/msw/server";
import { renderWithProviders, screen, waitFor } from "@/test-utils/render";
import { KnowledgeFilterPanel } from "./knowledge-filter-panel";
vi.mock("@/lib/analytics", () => ({ trackButton: vi.fn() }));
// The real brand provider reads localStorage; the picker only needs this flag.
vi.mock("@/contexts/brand-context", async (importOriginal) => ({
...(await importOriginal<typeof import("@/contexts/brand-context")>()),
useIsCloudBrand: () => false,
}));
const AFTER = "2026-10-07T07:00:00.000Z";
const BEFORE = "2026-10-11T06:59:59.999999Z";
const CONTEXT = {
from: "2026-10-07",
to: "2026-10-10",
timezone: "America/Los_Angeles",
};
const auth = withAuth(authPresets.admin, {
me: { run_mode: "oss" },
usersMe: { permissions: ["kf:create", "kf:edit:own"] },
});
type OneSided = { created_after?: string; created_before?: string };
function saved(withDates: boolean, oneSided?: OneSided) {
return {
id: "f1",
name: "PDFs",
description: "",
owner: "user-1",
created_at: "",
updated_at: "",
query_data: JSON.stringify({
query: "",
filters: {
data_sources: ["*"],
document_types: ["application/pdf"],
owners: ["*"],
connector_types: ["*"],
...(oneSided
? oneSided
: withDates && { created_after: AFTER, created_before: BEFORE }),
},
...((withDates || oneSided) && {
date_range_context: oneSided ? { timezone: CONTEXT.timezone } : CONTEXT,
}),
limit: 10,
scoreThreshold: 0,
color: "zinc",
icon: "filter",
}),
};
}
function Harness({
withDates,
create = false,
oneSided,
}: {
withDates: boolean;
create?: boolean;
oneSided?: OneSided;
}) {
const { setSelectedFilter, dateRange, setDateRange, startCreateMode } =
useKnowledgeFilter();
// biome-ignore lint/correctness/useExhaustiveDependencies: select once on mount
useEffect(() => {
if (!create) setSelectedFilter(saved(withDates, oneSided));
}, []);
return (
<>
<button type="button" onClick={startCreateMode}>
start-create
</button>
<button
type="button"
onClick={() => setDateRange({ from: new Date(2026, 8, 1) })}
>
toolbar-range
</button>
<output data-testid="toolbar">{dateRange ? "set" : "none"}</output>
<KnowledgeFilterPanel />
</>
);
}
let putBody: { queryData?: string } | undefined;
let postBody: { name?: string; queryData?: string } | undefined;
// A getter keeps TypeScript from narrowing the callback-assigned variable to never.
const createdBody = () => postBody;
async function renderPanel(withDates: boolean, oneSided?: OneSided) {
putBody = undefined;
server.use(
http.post("/api/search", () => HttpResponse.json({ aggregations: {} })),
http.put("/api/knowledge-filter/f1", async ({ request }) => {
putBody = (await request.json()) as { queryData?: string };
return HttpResponse.json({
success: true,
filter: saved(withDates, oneSided),
});
}),
);
renderWithProviders(<Harness withDates={withDates} oneSided={oneSided} />, {
providers: ["auth", "knowledgeFilter"],
auth,
});
await screen.findByText("Date ingested");
}
const savedQueryData = () => JSON.parse(putBody?.queryData ?? "{}");
async function click(el: HTMLElement) {
await act(async () => {
fireEvent.click(el);
});
}
async function save() {
await click(await screen.findByRole("button", { name: /update filter/i }));
await waitFor(() => expect(putBody).toBeDefined());
return savedQueryData();
}
describe("KnowledgeFilterPanel date ingested", () => {
beforeEach(() => {
vi.useFakeTimers({ toFake: ["Date"] });
vi.setSystemTime(new Date(2026, 9, 23, 12));
});
afterEach(() => vi.useRealTimers());
it("saves an unchanged dated filter with its exact bounds and context", async () => {
await renderPanel(true);
const data = await save();
expect(data.filters.created_after).toBe(AFTER);
expect(data.filters.created_before).toBe(BEFORE);
expect(data.filters.document_types).toEqual(["application/pdf"]);
expect(data.date_range_context).toEqual(CONTEXT);
expect(data.filters.date_range_context).toBeUndefined();
});
it("saves a filter without dates unrestricted", async () => {
await renderPanel(false);
const data = await save();
expect(data.filters).not.toHaveProperty("created_after");
expect(data.filters).not.toHaveProperty("created_before");
expect(data).not.toHaveProperty("date_range_context");
});
it("clears a saved range by choosing All dates", async () => {
await renderPanel(true);
await click(screen.getByRole("button", { name: /–/ }));
await click(await screen.findByRole("button", { name: "All dates" }));
await click(screen.getByRole("button", { name: "Apply" }));
const data = await save();
expect(data.filters).not.toHaveProperty("created_after");
expect(data.filters).not.toHaveProperty("created_before");
expect(data).not.toHaveProperty("date_range_context");
});
it("does not save a temporary toolbar range", async () => {
await renderPanel(false);
await click(screen.getByRole("button", { name: "toolbar-range" }));
expect(screen.getByTestId("toolbar")).toHaveTextContent("set");
const data = await save();
expect(data.filters).not.toHaveProperty("created_after");
expect(data).not.toHaveProperty("date_range_context");
});
it("creates a filter with the range picked in the toolbar", async () => {
postBody = undefined;
server.use(
http.post("/api/search", () => HttpResponse.json({ aggregations: {} })),
http.post("/api/knowledge-filter", async ({ request }) => {
postBody = (await request.json()) as typeof postBody;
return HttpResponse.json({ success: true, filter: saved(false) });
}),
);
renderWithProviders(<Harness withDates={false} create />, {
providers: ["auth", "knowledgeFilter"],
auth,
});
await click(screen.getByRole("button", { name: "toolbar-range" }));
expect(screen.getByTestId("toolbar")).toHaveTextContent("set");
await click(screen.getByRole("button", { name: "start-create" }));
await screen.findByText("Date ingested");
expect(screen.getByRole("button", { name: /^from/i })).toBeInTheDocument();
fireEvent.change(screen.getByPlaceholderText(/name/i), {
target: { value: "New filter" },
});
await click(screen.getByRole("button", { name: /create filter/i }));
await waitFor(() => expect(createdBody()).toBeDefined());
const data = JSON.parse(createdBody()?.queryData ?? "{}");
expect(data.filters.created_after).toBe(
toLocalDayStartISOString(new Date(2026, 8, 1)),
);
expect(data.filters).not.toHaveProperty("created_before");
expect(data.date_range_context).toMatchObject({ from: "2026-09-01" });
});
it.each([
["created_after", { created_after: "2026-10-07T07:00:00.000Z" }],
["created_before", { created_before: "2026-10-11T06:59:59.999999Z" }],
])("keeps a %s-only range when the field is applied without edits", async (key, oneSided) => {
await renderPanel(true, oneSided);
await click(screen.getByRole("button", { name: /^(From|Until) / }));
await click(await screen.findByRole("button", { name: "Apply" }));
const data = await save();
expect(data.filters[key]).toBe(Object.values(oneSided)[0]);
const other = key === "created_after" ? "created_before" : "created_after";
expect(data.filters).not.toHaveProperty(other);
});
it("offers All dates, 30/60/90 days and a custom range", async () => {
await renderPanel(false);
await click(
screen.getByRole("button", { name: /filter by date ingested/i }),
);
for (const name of [
"All dates",
"Last 30 days",
"Last 60 days",
"Last 90 days",
"Custom date range",
]) {
expect(screen.getByRole("button", { name })).toBeInTheDocument();
}
expect(screen.getByRole("button", { name: "All dates" })).toHaveAttribute(
"aria-pressed",
"true",
);
});
it("saves a Last 30 days selection as full local-day bounds", async () => {
await renderPanel(false);
await click(
screen.getByRole("button", { name: /filter by date ingested/i }),
);
await click(screen.getByRole("button", { name: "Last 30 days" }));
await click(screen.getByRole("button", { name: "Apply" }));
const data = await save();
// today is faked as 2026-10-23, so 30 days is Sep 24 - Oct 23 inclusive.
expect(new Date(data.filters.created_after).getTime()).toBe(
new Date(2026, 8, 24).getTime(),
);
expect(new Date(data.filters.created_before).getTime()).toBeGreaterThan(
new Date(2026, 9, 23, 23, 59).getTime(),
);
expect(data.date_range_context.from).toBe("2026-09-24");
expect(data.date_range_context.to).toBe("2026-10-23");
});
it("discards the draft on Cancel", async () => {
await renderPanel(false);
await click(
screen.getByRole("button", { name: /filter by date ingested/i }),
);
await click(screen.getByRole("button", { name: "Last 90 days" }));
await click(screen.getByRole("button", { name: "Cancel" }));
const data = await save();
expect(data.filters).not.toHaveProperty("created_after");
});
it("sets From and To through the date fields", async () => {
await renderPanel(false);
await click(
screen.getByRole("button", { name: /filter by date ingested/i }),
);
await click(screen.getByRole("button", { name: "Custom date range" }));
expect(screen.getByRole("button", { name: "From date" })).toHaveAttribute(
"aria-expanded",
"true",
);
const dayButton = (n: number) =>
screen
.getAllByRole("gridcell")
.find(
(c) =>
c.tagName === "BUTTON" &&
!c.className.includes("day-outside") &&
c.textContent === String(n),
) as HTMLElement;
await click(dayButton(7));
await click(screen.getByRole("button", { name: "To date" }));
// The To calendar opens on its own value's month (October).
await click(dayButton(10));
await click(screen.getByRole("button", { name: "Apply" }));
const data = await save();
// Custom starts as Sep 24 - Oct 23, so the From calendar opens on September.
expect(data.date_range_context.from).toBe("2026-09-07");
// A To before the draft's start would invert the range; the field keeps it
// disabled, so the To pick above is the first selectable day on or after From.
expect(data.date_range_context.to).toBe("2026-10-10");
});
});