Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Enable explorations (#82594)

Kevin Kelleher504b8ea9ee13
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 66a6a0514ab..bef9e64fb3a 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -1004,7 +1004,7 @@
explorations
{:team "UX West"
- :api #{metabase.explorations.core metabase.explorations.init metabase.explorations.schema}
+ :api #{metabase.explorations.api metabase.explorations.core metabase.explorations.init metabase.explorations.schema}
:uses #{analytics
analytics.interface
api
diff --git a/e2e/test/scenarios/collections/collections.cy.spec.js b/e2e/test/scenarios/collections/collections.cy.spec.js
index 1ca47c72469..4fe2d20562d 100644
--- a/e2e/test/scenarios/collections/collections.cy.spec.js
+++ b/e2e/test/scenarios/collections/collections.cy.spec.js
@@ -1337,7 +1337,7 @@ describe("scenarios > collection items listing", () => {
cy.findByRole("button", { name: "Filter" }).click();
H.popover().within(() => {
- cy.findAllByRole("checkbox").should("have.length", 7);
+ cy.findAllByRole("checkbox").should("have.length", 8);
cy.findByLabelText("Collection").should("not.be.checked");
cy.findByLabelText("Dashboard").should("not.be.checked");
cy.findByLabelText("Question").should("not.be.checked");
diff --git a/e2e/test/scenarios/explorations/explorations.cy.spec.ts b/e2e/test/scenarios/explorations/explorations.cy.spec.ts
new file mode 100644
index 00000000000..720335f65c0
--- /dev/null
+++ b/e2e/test/scenarios/explorations/explorations.cy.spec.ts
@@ -0,0 +1,1418 @@
+import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
+import type { StructuredQuestionDetails } from "e2e/support/helpers";
+import type {
+ Exploration,
+ GetExplorationDataResponse,
+} from "metabase-types/api";
+
+const { H } = cy;
+const { ORDERS_ID, ORDERS, PRODUCTS } = SAMPLE_DATABASE;
+
+type StructuredQuestionDetailsWithName = StructuredQuestionDetails & {
+ name: string;
+};
+
+const ORDERS_COUNT_METRIC_NAME = "Count of orders";
+const ORDERS_COUNT_METRIC: StructuredQuestionDetailsWithName = {
+ name: ORDERS_COUNT_METRIC_NAME,
+ type: "metric" as const,
+ query: {
+ "source-table": ORDERS_ID,
+ aggregation: [["count"]],
+ },
+ display: "scalar" as const,
+};
+
+const ORDERS_TIMESERIES_METRIC_NAME = "Count of orders over time";
+const ORDERS_TIMESERIES_METRIC: StructuredQuestionDetailsWithName = {
+ name: ORDERS_TIMESERIES_METRIC_NAME,
+ type: "metric" as const,
+ query: {
+ "source-table": ORDERS_ID,
+ aggregation: [["count"]],
+ breakout: [
+ [
+ "field",
+ ORDERS.CREATED_AT,
+ { "base-type": "type/DateTime", "temporal-unit": "month" },
+ ],
+ ],
+ },
+ display: "line" as const,
+};
+
+function seedMetrics() {
+ for (const metric of [ORDERS_COUNT_METRIC, ORDERS_TIMESERIES_METRIC]) {
+ H.createQuestion(metric).then(({ body }) => {
+ // The response is unused, but `GET /api/metric/:id` calls
+ // `sync-dimensions!` server-side, persisting the metric's dimensions
+ // and dimension_mappings — which `/api/exploration/dimensions` needs.
+ cy.request("GET", `/api/metric/${body.id}`);
+ });
+ }
+}
+
+/**
+ * Create a timeline + one sentinel event in a single chain. The
+ * Exploration timeline picker (`useGetExplorationTimelinesQuery`) hides
+ * timelines without events, so test fixtures that want to surface the
+ * timeline in the picker — or attach it to an exploration — need at
+ * least one event hanging off it.
+ *
+ * Returns the new `timeline_id` so callers that need it (e.g. to assert
+ * a request body's `timeline_ids` field) can chain off it; call sites
+ * that just need the timeline to exist can ignore the return value.
+ */
+function createTimelineWithSentinelEvent(
+ name: string,
+ icon: string,
+): Cypress.Chainable<number> {
+ return cy
+ .request("POST", "/api/timeline", {
+ name,
+ collection_id: null,
+ icon,
+ default: false,
+ })
+ .then(({ body }: { body: { id: number } }) => {
+ const timelineId = body.id;
+ return cy
+ .request("POST", "/api/timeline-event", {
+ timeline_id: timelineId,
+ name: `${name} event`,
+ icon,
+ timestamp: "2026-01-01T00:00:00Z",
+ time_matters: false,
+ timezone: "UTC",
+ })
+ .then(() => timelineId);
+ });
+}
+
+describe("scenarios > explorations > new research > manual flow", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("picks Our analytics + metrics + timelines, creates an exploration, and lands on the detail page", () => {
+ createTimelineWithSentinelEvent("Releases", "star").then((releasesId) => {
+ createTimelineWithSentinelEvent("Marketing campaigns", "bell").then(
+ (marketingId) => {
+ H.visitNewExploration();
+
+ // Root is a FE-only id (`"root"`); the create POST must send
+ // `collection_id: null` or the BE schema rejects it.
+ cy.findByRole("button", { name: /Personal collection/i }).click();
+ H.pickEntity({ path: ["Our analytics"], select: true });
+ cy.findByRole("button", { name: /Our analytics/i }).should(
+ "be.visible",
+ );
+
+ H.startManualExploration();
+
+ // Manual setup is its own location, so browser back returns here
+ // instead of leaving the research flow (UXW-4832).
+ cy.location("pathname").should("eq", "/question/research/plan");
+
+ H.addMetricsToExploration({
+ metrics: [ORDERS_COUNT_METRIC_NAME],
+ });
+
+ cy.findByTestId("research-content")
+ .should("be.visible")
+ .and("contain", ORDERS_COUNT_METRIC_NAME);
+
+ // Pick two timelines via the "+ Events" modal.
+ H.addTimelinesToExploration(["Marketing campaigns", "Releases"]);
+
+ // The first picked timeline shows as a pill next to the Events
+ // button; the rest collapse into a "+N" overflow pill.
+ cy.findByTestId("selected-timelines-container").within(() => {
+ cy.findByText("Marketing campaigns").should("be.visible");
+ cy.findByText("+1").should("be.visible");
+ });
+
+ H.beginResearch().then((id) => {
+ // `beginResearch` consumed the create request; re-read it off its
+ // alias to assert timeline ids + root collection were forwarded.
+ cy.get("@createExploration")
+ .its("request.body")
+ .should((body) => {
+ expect(body.timeline_ids).to.deep.eq([marketingId, releasesId]);
+ expect(body.collection_id).to.eq(null);
+ });
+
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_plan_edited",
+ triggered_from: "manual",
+ event_detail: "metrics",
+ });
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_plan_edited",
+ triggered_from: "manual",
+ event_detail: "timelines",
+ });
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_created",
+ target_id: id,
+ });
+
+ // `beginResearch` already asserted the detail-page URL.
+ // No new-exploration CTA on the detail page.
+ cy.findByRole("button", { name: /Start research/i }).should(
+ "not.exist",
+ );
+ });
+ },
+ );
+ });
+ });
+
+ it("filters Exploration data pickers by typing into their search inputs", () => {
+ // Both timelines need an event so the picker surfaces them — the
+ // empty-state case is still exercised by the "no match" search at
+ // the bottom of this test.
+ createTimelineWithSentinelEvent("Releases", "star");
+ createTimelineWithSentinelEvent("Marketing campaigns", "bell");
+
+ H.visitNewExploration();
+ H.startManualExploration();
+
+ // --- "+ Metrics" modal search ---
+ cy.findByRole("button", { name: /Metrics/ }).click();
+ // Seeded names are "Count of orders" + "Count of orders over time".
+ cy.wait("@getDimensions");
+ // Seeded metrics aren't in the library; switch off the default Library tab.
+ H.selectAllMetricsTab();
+ cy.findByRole("checkbox", { name: ORDERS_COUNT_METRIC_NAME }).should(
+ "exist",
+ );
+ cy.findByRole("checkbox", { name: ORDERS_TIMESERIES_METRIC_NAME }).should(
+ "exist",
+ );
+
+ // Type a substring that only matches the timeseries metric.
+ cy.findByPlaceholderText("Search for a metric").type("over time");
+ cy.wait("@getDimensions");
+ cy.findByRole("checkbox", { name: ORDERS_TIMESERIES_METRIC_NAME }).should(
+ "exist",
+ );
+ cy.findByRole("checkbox", { name: ORDERS_COUNT_METRIC_NAME }).should(
+ "not.exist",
+ );
+
+ // Clear the input → both rows return.
+ cy.findByPlaceholderText("Search for a metric").clear();
+ cy.findByRole("checkbox", { name: ORDERS_COUNT_METRIC_NAME }).should(
+ "exist",
+ );
+ cy.findByRole("checkbox", { name: ORDERS_TIMESERIES_METRIC_NAME }).should(
+ "exist",
+ );
+
+ // Search for something that matches no metric → empty-state copy.
+ cy.findByPlaceholderText("Search for a metric").type("zzz");
+ cy.wait("@getDimensions");
+ cy.findByRole("dialog").should("contain", "No results");
+
+ // Close the metrics modal before opening the events one.
+ cy.get("body").type("{esc}");
+
+ // --- "+ Events" modal search ---
+ cy.findByRole("button", { name: /Events/ }).click();
+ cy.findByRole("checkbox", { name: "Releases" }).should("exist");
+ cy.findByRole("checkbox", { name: "Marketing campaigns" }).should("exist");
+
+ // Filter to just one timeline by name fragment.
+ cy.findByPlaceholderText("Search for a timeline").type("release");
+ cy.findByRole("checkbox", { name: "Releases" }).should("exist");
+ cy.findByRole("checkbox", { name: "Marketing campaigns" }).should(
+ "not.exist",
+ );
+
+ // Clear → both return.
+ cy.findByPlaceholderText("Search for a timeline").clear();
+ cy.findByRole("checkbox", { name: "Releases" }).should("exist");
+ cy.findByRole("checkbox", { name: "Marketing campaigns" }).should("exist");
+ });
+});
+
+describe("scenarios > explorations > new research > metabot flow", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("auto-populates metrics + dimensions + name from agent tool calls, then Start research succeeds", () => {
+ cy.request("GET", "/api/exploration/dimensions").then(({ body }) => {
+ // Unjustified type cast. FIXME
+ const data = body as {
+ metrics: Array<{ id: number; name: string; dimension_ids: string[] }>;
+ dimension_groups: Array<{
+ name: string;
+ dimension_interestingness: number | null;
+ dimensions: Array<{
+ id: string;
+ name: string;
+ display_name: string;
+ dimension_interestingness: number | null;
+ }>;
+ }>;
+ };
+
+ const firstMetric = data.metrics[0];
+ const interestingGroup =
+ data.dimension_groups.find((g) =>
+ g.dimensions.some((d) => (d.dimension_interestingness ?? 0) >= 0.7),
+ ) ?? data.dimension_groups[0];
+ expect(
+ firstMetric,
+ "seeded metric is exposed by /api/exploration/dimensions",
+ ).to.exist;
+ expect(interestingGroup, "at least one dimension group is exposed").to
+ .exist;
+
+ const agentName = "New exploration";
+ H.mockExplorationsAgentToolCalls([
+ {
+ toolCallId: "groups-1",
+ toolName: "add_research_groups",
+ // The tool result is only the LLM's summary of the edit; the picker
+ // hydration rides a `research_plan_update` data part.
+ result: `Added 1 group(s) to the research plan:\n- ${firstMetric.name}, by the automatically-selected dimensions`,
+ dataParts: [
+ {
+ dataType: "research_plan_update",
+ data: {
+ metrics: [firstMetric],
+ dimension_groups: [interestingGroup],
+ groups: [{ metric_id: firstMetric.id }],
+ },
+ },
+ ],
+ },
+ {
+ toolCallId: "name-1",
+ toolName: "set_research_name",
+ result: { name: agentName },
+ },
+ ]);
+
+ H.visitNewExploration();
+
+ H.explorationsMetabotPromptInput().type("Why are signups down?");
+ cy.findByRole("button", { name: /Create plan/i }).click();
+
+ // The chat dispatch went through with the `explorations`
+ // profile, confirming we wired the new-exploration page to
+ // the right agent.
+ cy.wait("@metabotAgent")
+ .its("request.body.profile_id")
+ .should("eq", "explorations");
+
+ // Right panel hydrated from the tool-call result — the agent's
+ // metric now heads a research-plan block.
+ cy.findByRole("main").findByText(firstMetric.name).should("be.visible");
+
+ // Click Start research; the create-exploration POST body
+ // should carry the name the agent picked.
+ cy.intercept("POST", "/api/exploration").as("createExploration");
+ cy.findByRole("button", { name: /Start research/i }).click();
+ cy.wait("@createExploration").then(({ request, response }) => {
+ expect(request.body.name).to.eq(agentName);
+ // Unjustified type cast. FIXME
+ const id = response?.body?.id as number;
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_agent_message_sent",
+ });
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_plan_edited",
+ triggered_from: "agent",
+ event_detail: "metrics",
+ });
+ H.expectUnstructuredSnowplowEvent({
+ event: "exploration_created",
+ target_id: id,
+ });
+ });
+ });
+ });
+});
+
+describe("scenarios > explorations > detail page", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("changes sidebar selection on click and shows the corresponding visualization area", () => {
+ H.createExplorationViaApi({ name: "Click selection fixture" }).then(
+ (id) => {
+ visitExplorationUntilSettled(id, 2);
+
+ // The page auto-selects a row on load, so clicking the first (already
+ // selected) row would pass even with click-to-select broken. Click a
+ // row that is NOT selected and assert the selection moves to it.
+ cy.findAllByRole("treeitem")
+ .filter('[aria-selected="false"]')
+ .eq(1) // first treeitem is the summary document
+ .invoke("attr", "href")
+ .then((href) => {
+ cy.get(`[role="treeitem"][href="${href}"]`).click();
+ cy.get(`[role="treeitem"][href="${href}"]`).should(
+ "have.attr",
+ "aria-selected",
+ "true",
+ );
+ });
+
+ // The clicked page's chart renders in the main area — assert a real
+ // visualization anchor, not just "main is not empty" (a spinner
+ // satisfies that).
+ cy.location("pathname").should("match", /\/page\/\d+$/);
+ cy.findByRole("main")
+ .findByTestId("visualization-root", { timeout: 15000 })
+ .should("be.visible");
+ },
+ );
+ });
+
+ it("preserves the URL `timeline` param across navigation and reload", () => {
+ createTimelineWithSentinelEvent("Releases", "star").then((timelineId) => {
+ cy.request("GET", "/api/exploration/dimensions").then(({ body }) => {
+ // Unjustified type cast. FIXME
+ const data = body as GetExplorationDataResponse;
+ const temporalDimension = data.dimension_groups
+ .flatMap((group) => group.dimensions)
+ .find((dim) => dim.effective_type.includes("Date"));
+ expect(temporalDimension, "sample DB exposes a temporal dimension").to
+ .exist;
+
+ H.createExplorationViaApi({
+ name: "Timeline persistence fixture",
+ timelineIds: [timelineId],
+ dimensionIds: [temporalDimension!.id],
+ }).then((id) => {
+ cy.visit(`/question/research/${id}?timeline=${timelineId}`);
+ // Sidebar treeitems appear once the BE returns query rows.
+ cy.findAllByRole("treeitem", { timeout: 15000 })
+ .first()
+ .should("be.visible");
+
+ cy.findByRole("treeitem", {
+ name: new RegExp(`${temporalDimension!.display_name}$`), // anchor at end so we don't match day of week or hour of day
+ }).click();
+
+ cy.findByTestId("exploration-chart-grid").within(() => {
+ H.timelineEventChip("Releases event").should("be.visible");
+ });
+
+ cy.location("search").should("include", `timeline=${timelineId}`);
+
+ // Reload — the URL param is the source of truth and the
+ // router shouldn't rewrite it away on hydration.
+ cy.reload();
+ cy.findAllByRole("treeitem", { timeout: 15000 })
+ .first()
+ .should("be.visible");
+ cy.location("search").should("include", `timeline=${timelineId}`);
+
+ cy.findByTestId("exploration-chart-grid").within(() => {
+ H.timelineEventChip("Releases event").should("be.visible");
+ });
+ });
+ });
+ });
+ });
+});
+
+/**
+ * Resolve the "Count of orders" metric plus its first two dimensions and
+ * create an exploration with them — yielding one metric-group heading with
+ * exactly two dimension-named pages, the smallest deterministic tree for
+ * sidebar-triage assertions.
+ */
+function createTwoPageExploration(name: string): Cypress.Chainable<{
+ explorationId: number;
+ metricName: string;
+ pageNames: string[];
+}> {
+ return cy.request("GET", "/api/exploration/dimensions").then(({ body }) => {
+ // Unjustified type cast. FIXME
+ const data = body as GetExplorationDataResponse;
+ const ordersMetric = data.metrics.find(
+ (metric) => metric.name === ORDERS_COUNT_METRIC_NAME,
+ );
+ expect(
+ ordersMetric,
+ `"${ORDERS_COUNT_METRIC_NAME}" metric is exposed by /api/exploration/dimensions`,
+ ).to.exist;
+ const dimsById = new Map(
+ data.dimension_groups.flatMap((group) =>
+ group.dimensions.map((dim) => [dim.id, dim] as const),
+ ),
+ );
+ const pickedDimensions = ordersMetric!.dimension_ids
+ .map((id) => dimsById.get(id))
+ .filter((dim) => dim != null)
+ .slice(0, 2);
+ expect(
+ pickedDimensions.length,
+ "metric exposes at least two dimensions",
+ ).to.eq(2);
+
+ return H.createExplorationViaApi({
+ name,
+ metricCardIds: [ordersMetric!.id],
+ dimensionIds: pickedDimensions.map((dim) => dim!.id),
+ }).then((explorationId) => ({
+ explorationId,
+ metricName: ordersMetric!.name,
+ pageNames: pickedDimensions.map((dim) => dim!.display_name),
+ }));
+ });
+}
+
+/**
+ * Visit an exploration and wait until it has fully settled. The "Ready" icons
+ * only say every page's queries finished; the page keeps polling
+ * `GET /api/exploration/:id` (rebuilding the sidebar tree on each response)
+ * until the BE also stamps the thread's `completed_at` after its post-query
+ * handling. Interact with the tree only after that final response, or clicks
+ * can land on nodes a re-render just replaced.
+ */
+function visitExplorationUntilSettled(
+ explorationId: number,
+ minReadyCount: number,
+): void {
+ cy.intercept("GET", `/api/exploration/${explorationId}`).as("getExploration");
+ H.visitExploration(explorationId);
+ cy.findAllByLabelText("Ready", { timeout: 30000 }).should(
+ "have.length.at.least",
+ minReadyCount,
+ );
+ const awaitThreadCompletion = (attempt: number) => {
+ cy.wait("@getExploration", { timeout: 30000 }).then(({ response }) => {
+ // Unjustified type cast. FIXME
+ const threads = (response?.body as Exploration).threads ?? [];
+ if (!threads.every((thread) => thread.completed_at != null)) {
+ expect(
+ attempt,
+ "exploration completes within the poll budget",
+ ).to.be.lessThan(30);
+ awaitThreadCompletion(attempt + 1);
+ }
+ });
+ };
+ awaitThreadCompletion(0);
+}
+
+/**
+ * The FE polls every 2s while the new thread's queries are in flight, then
+ * toasts once its first page lands. Timing is covered by
+ * ExplorationPage.unit.spec.tsx — here we just wait for the real BE.
+ * Scoped to the toast container so we don't match the thread name in the
+ * sidebar.
+ */
+function openExploreFurtherToast(threadName: string): void {
+ H.undoToastListContainer().within(() => {
+ cy.findByText(`Added ${threadName}`, { timeout: 60000 }).should(
+ "be.visible",
+ );
+ cy.findByRole("button", { name: "View" }).click();
+ });
+}
+
+describe("scenarios > explorations > sidebar triage", () => {
+ const sidebar = () => cy.findByTestId("exploration-page-sidebar");
+ const filterToggle = () => cy.findByTestId("exploration-show-hidden-toggle");
+ const selectedRows = () =>
+ cy.findAllByRole("treeitem").filter('[aria-selected="true"]');
+ const toggleShowHiddenItems = () => {
+ filterToggle().click();
+ H.menu().findByText("Show hidden items").click();
+ cy.get("body").type("{esc}");
+ };
+
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("filters pages with the Stars and Discussions tabs and persists the sort preference across reloads", () => {
+ createTwoPageExploration("Sidebar tabs fixture").then(
+ ({ explorationId, pageNames }) => {
+ visitExplorationUntilSettled(explorationId, 2);
+
+ cy.log("Stars tab is empty until something is starred");
+ cy.findByRole("radio", { name: "Stars" }).click({ force: true });
+ cy.location("search").should("include", "tab=stars");
+ H.main().findByText("Nothing's been starred yet.").should("be.visible");
+ cy.findAllByRole("treeitem").should("not.exist");
+
+ cy.log("Discussions tab shows its own empty message");
+ cy.findByRole("radio", { name: "Discussions" }).click({ force: true });
+ H.main().findByText("No discussions yet.").should("be.visible");
+ cy.findAllByRole("treeitem").should("not.exist");
+
+ cy.log("Star the selected page with the s shortcut");
+ cy.findByRole("radio", { name: "All" }).click({ force: true });
+ cy.findAllByRole("treeitem").should("have.length", 3); // summary document + 2 pages
+ sidebar().findByText(pageNames[0]).click();
+ selectedRows().should("contain.text", pageNames[0]);
+ cy.intercept("PUT", "/api/exploration/page/*/starred").as("setStarred");
+ cy.get("body").type("s");
+ cy.wait("@setStarred").its("request.body.starred").should("eq", true);
+ H.main()
+ .findByRole("button", { name: "Remove star" })
+ .should("be.visible");
+
+ cy.log("The c shortcut opens the comment editor");
+ cy.get("body").type("c");
+ // The editor's placeholder is CSS-rendered by TipTap (not real text),
+ // so anchor on the editor's Send button instead. The popover is
+ // portaled outside <main>.
+ H.popover().findByRole("button", { name: "Send" }).should("be.visible");
+ H.main().findByRole("button", { name: "Add comment" }).click();
+ cy.findByRole("button", { name: "Send" }).should("not.exist");
+
+ cy.log("The l shortcut copies a link to the selected page");
+ // Headless Chrome denies real clipboard access here (NotAllowedError),
+ // so stub the write and assert the call instead of reading it back.
+ cy.window().then((win) => {
+ cy.stub(win.navigator.clipboard, "writeText")
+ .as("copyToClipboard")
+ .resolves();
+ });
+ cy.get("body").type("l");
+ H.undoToastListContainer()
+ .findByText("Copied link")
+ .should("be.visible");
+ cy.location("href").then((href) => {
+ cy.get("@copyToClipboard").should("have.been.calledWith", href);
+ });
+
+ cy.log("Stars tab now shows only the starred page");
+ cy.findByRole("radio", { name: "Stars" }).click({ force: true });
+ cy.findAllByRole("treeitem")
+ .should("have.length", 1)
+ .first()
+ .should("contain.text", pageNames[0]);
+
+ cy.log("Alphabetical sort is remembered per exploration");
+ cy.findByRole("radio", { name: "All" }).click({ force: true });
+ // Assert and click through separate queries — chaining `.click()` off
+ // the assertion can act on a node a poll-driven re-render detached.
+ filterToggle().should("have.attr", "aria-pressed", "false");
+ filterToggle().click();
+ H.menu().findByText("Alphabetical").click();
+ H.menu()
+ .findByRole("menuitem", { name: /Alphabetical/ })
+ .should("have.attr", "data-checked", "true");
+ cy.get("body").type("{esc}");
+ cy.log("Sorting is not a filter, so the toggle stays unfilled");
+ filterToggle().should("have.attr", "aria-pressed", "false");
+
+ cy.reload();
+ cy.findAllByRole("treeitem", { timeout: 15000 })
+ .first()
+ .should("be.visible");
+ filterToggle().should("have.attr", "aria-pressed", "false");
+ filterToggle().click();
+ H.menu()
+ .findByRole("menuitem", { name: /Alphabetical/ })
+ .should("have.attr", "data-checked", "true");
+ },
+ );
+ });
+
+ it("hides pages from the toolbar and group menus and reveals them via Show hidden items", () => {
+ createTwoPageExploration("Sidebar hide fixture").then(
+ ({ explorationId, metricName, pageNames }) => {
+ cy.intercept("PUT", "/api/exploration/pages/hidden").as(
+ "setPagesHidden",
+ );
+ visitExplorationUntilSettled(explorationId, 2);
+
+ // The page auto-selects the tree's first page on load, and the tree
+ // orders pages by interestingness — so which of the two
+ // dimension-named pages is selected is data-dependent; derive it
+ // from the DOM instead of assuming.
+ cy.findAllByRole("treeitem").should("have.length", 3); // summary document + 2 pages
+ selectedRows().should("have.length", 1);
+ selectedRows()
+ .first()
+ .invoke("text")
+ .then((text) => {
+ const firstPageName = text.trim();
+ const secondPageName = pageNames.find(
+ (name) => name !== firstPageName,
+ )!;
+
+ cy.log("Triage arrows step between pages");
+ cy.findByRole("button", { name: "Next" }).click();
+ selectedRows().should("contain.text", secondPageName);
+ cy.findByRole("button", { name: "Previous" }).click();
+ selectedRows().should("contain.text", firstPageName);
+
+ cy.log("Hide the selected page with the h shortcut");
+ cy.get("body").type("h");
+ cy.wait("@setPagesHidden").then(({ request }) => {
+ expect(request.body.hidden).to.eq(true);
+ expect(request.body.page_ids).to.have.length(1);
+ });
+ H.undoToastListContainer()
+ .findByText(`"${firstPageName}" hidden`)
+ .should("be.visible");
+
+ cy.log("Auto-advance moves the selection to the remaining page");
+ selectedRows().should("contain.text", secondPageName);
+ cy.findAllByRole("treeitem").should("have.length", 2); // summary document + 1 non-hidden page
+ sidebar().findByText(firstPageName).should("not.exist");
+
+ cy.log("Show hidden items reveals the page with a Hidden marker");
+ toggleShowHiddenItems();
+ filterToggle().should("have.attr", "aria-pressed", "true");
+ sidebar().findByText(firstPageName).should("be.visible");
+ sidebar().findAllByLabelText("Hidden").should("have.length", 1);
+ toggleShowHiddenItems();
+ cy.findAllByRole("treeitem").should("have.length", 2);
+ sidebar().findByText(firstPageName).should("not.exist");
+ });
+
+ cy.log("Hide the whole group from its actions menu");
+ sidebar()
+ .findByRole("group", { name: metricName })
+ .findByRole("button", { name: "Group actions" })
+ .click({ force: true });
+ H.menu().findByText("Hide").click();
+ cy.wait("@setPagesHidden")
+ .its("request.body.hidden")
+ .should("eq", true);
+ H.undoToastListContainer()
+ .findByText(`${metricName} hidden`)
+ .should("be.visible");
+
+ cy.log("Everything but the summary document is hidden");
+ cy.findAllByRole("treeitem").should("have.length", 1);
+
+ cy.log("Hidden state is persisted server-side across a reload");
+ cy.reload();
+ cy.findAllByRole("treeitem").should("have.length", 1);
+
+ cy.log("Show hidden items + the group Show action restore the pages");
+ toggleShowHiddenItems();
+ cy.findAllByRole("treeitem").should("have.length", 3);
+ sidebar().findAllByLabelText("Hidden").should("have.length", 2);
+ sidebar()
+ .findByRole("group", { name: metricName })
+ .findByRole("button", { name: "Group actions" })
+ .click({ force: true });
+ H.menu().findByText("Show").click();
+ cy.wait("@setPagesHidden")
+ .its("request.body.hidden")
+ .should("eq", false);
+ cy.findAllByRole("treeitem").should("have.length", 3);
+ sidebar().findAllByLabelText("Hidden").should("not.exist");
+
+ cy.log("Hiding the group with every page visible sends both page ids");
+ toggleShowHiddenItems();
+ cy.findAllByRole("treeitem").should("have.length", 3);
+ sidebar()
+ .findByRole("group", { name: metricName })
+ .findByRole("button", { name: "Group actions" })
+ .click({ force: true });
+ H.menu().findByText("Hide").click();
+ cy.wait("@setPagesHidden").then(({ request }) => {
+ expect(request.body.hidden).to.eq(true);
+ expect(request.body.page_ids).to.have.length(2);
+ });
+ cy.findAllByRole("treeitem").should("have.length", 1);
+
+ cy.log("Undo on the group-hidden toast restores the whole group");
+ H.undoToastListContainer()
+ .findByText(`${metricName} hidden`)
+ .should("be.visible");
+ H.undoToastListContainer()
+ .findByRole("button", { name: "Undo" })
+ .click();
+ cy.wait("@setPagesHidden")
+ .its("request.body.hidden")
+ .should("eq", false);
+ cy.findAllByRole("treeitem").should("have.length", 3);
+ },
+ );
+ });
+});
+
+describe("scenarios > explorations > chart click-through", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("clicking a cartesian point opens Explore further + Add comment, posts explore-further filters, and navigates from the new-thread toast", () => {
+ createTimelineWithSentinelEvent("Releases", "star").then((timelineId) => {
+ cy.request("GET", "/api/exploration/dimensions").then(({ body }) => {
+ // manual typecast for BE data
+ const seeded = body as GetExplorationDataResponse;
+ const seededMetric = seeded.metrics.find(
+ (metric) => metric.name === ORDERS_COUNT_METRIC_NAME,
+ );
+ expect(
+ seededMetric,
+ `"${ORDERS_COUNT_METRIC_NAME}" metric is exposed by /api/exploration/dimensions`,
+ ).to.exist;
+ cy.request("POST", `/api/metric/${seededMetric!.id}/dimension/add`, {
+ dimensions: [
+ {
+ id: "e2e00000-cafe-4bb8-9d8a-0123456789ab",
+ mapping_target: [
+ "field",
+ { "source-field": ORDERS.PRODUCT_ID },
+ PRODUCTS.CATEGORY,
+ ],
+ },
+ ],
+ });
+ });
+
+ cy.request("GET", "/api/exploration/dimensions").then(({ body }) => {
+ // Unjustified type cast. FIXME
+ const data = body as GetExplorationDataResponse;
+ const ordersMetric = data.metrics.find(
+ (metric) => metric.name === ORDERS_COUNT_METRIC_NAME,
+ );
+ expect(
+ ordersMetric,
+ `"${ORDERS_COUNT_METRIC_NAME}" metric is exposed by /api/exploration/dimensions`,
+ ).to.exist;
+ const dimsById = new Map(
+ data.dimension_groups.flatMap((group) =>
+ group.dimensions.map((dim) => [dim.id, dim] as const),
+ ),
+ );
+ const dimension = ordersMetric!.dimension_ids
+ .map((id) => dimsById.get(id))
+ .find((dim) => dim != null && dim.display_name === "Category");
+ expect(
+ dimension,
+ 'orders metric exposes the curated "Category" dimension',
+ ).to.exist;
+
+ H.createExplorationViaApi({
+ name: "Chart click-through fixture",
+ metricCardIds: [ordersMetric!.id],
+ dimensionIds: [dimension!.id],
+ timelineIds: [timelineId],
+ }).then((explorationId) => {
+ let initialThreadIds: number[] = [];
+
+ cy.intercept(
+ "POST",
+ `/api/exploration/${explorationId}/explore-further`,
+ ).as("exploreFurther");
+
+ cy.visit(
+ `/question/research/${explorationId}?timeline=${timelineId}`,
+ );
+ cy.findAllByRole("treeitem", { timeout: 30000 })
+ .first()
+ .should("be.visible");
+
+ cy.request("GET", `/api/exploration/${explorationId}`).then(
+ ({ body }) => {
+ // Unjustified type cast. FIXME
+ const exploration = body as Exploration;
+ initialThreadIds = (exploration.threads ?? []).map(
+ (thread) => thread.id,
+ );
+ // Navigate straight to the dimension's page. Driving the
+ // sidebar here would depend on which group happens to be
+ // auto-expanded — a state this test doesn't control.
+ const pages = (exploration.threads ?? []).flatMap((thread) =>
+ (thread.blocks ?? []).flatMap((block) => block.pages ?? []),
+ );
+ const page = pages.find((p) =>
+ (p.name ?? "").includes(dimension!.display_name),
+ );
+ expect(page, "the dimension's page exists on the exploration").to
+ .exist;
+ cy.wrap(page!.id).as("pageId");
+ cy.visit(
+ `/question/research/${explorationId}/page/${page!.id}?timeline=${timelineId}`,
+ );
+ },
+ );
+
+ cy.location("pathname").should("include", "/page/");
+
+ // Wait for the selected page's queries to settle before clicking
+ // the chart — `Ready` is the settled-state icon label.
+ cy.findAllByLabelText("Ready", { timeout: 30000 })
+ .first()
+ .should("be.visible");
+
+ H.chartPathWithFillColor("#509EE3").first().click({ force: true });
+
+ cy.findByTestId("click-actions-view").within(() => {
+ cy.findByRole("button", { name: /Explore further/i }).should(
+ "be.visible",
+ );
+ cy.findByRole("button", { name: /Add comment/i }).should(
+ "be.visible",
+ );
+ });
+
+ cy.findByTestId("click-actions-view")
+ .findByRole("button", { name: /Explore further/i })
+ .click();
+
+ cy.wait("@exploreFurther").then(({ request, response }) => {
+ cy.get("@pageId").then((pageId) => {
+ expect(request.body.page_id).to.eq(pageId);
+ });
+ expect(request.body.explore_filters).to.be.an("array").and.not.be
+ .empty;
+ expect(request.body.explore_filters[0]).to.include.keys(
+ "operator",
+ "field_ref",
+ "value",
+ "display_value",
+ );
+ expect(request.body.explore_filters[0].operator).to.eq("=");
+
+ // Unjustified type cast. FIXME
+ const threads = (response?.body as Exploration).threads ?? [];
+ const newThread = threads.find(
+ (thread) => !initialThreadIds.includes(thread.id),
+ );
+ expect(newThread, "explore-further adds a new thread").to.exist;
+ cy.wrap(newThread!.name).as("newThreadName");
+ });
+
+ cy.get<string>("@newThreadName").then((name) => {
+ openExploreFurtherToast(name);
+ });
+
+ cy.location("pathname").should(
+ "include",
+ `/question/research/${explorationId}/page/`,
+ );
+ cy.location("search").should("include", "tab=all");
+ cy.location("search").should("include", `timeline=${timelineId}`);
+
+ cy.get("@newThreadName").then((name) => {
+ cy.findByRole("group", { name: String(name) }).should(
+ "have.attr",
+ "aria-expanded",
+ "true",
+ );
+ });
+
+ cy.findByRole("main")
+ .findByTestId("exploration-chart-grid")
+ .should("exist");
+ });
+ });
+ });
+ });
+
+ it("brushing a timeseries cartesian chart opens Explore further only, posts between explore_filters, navigates from the new-thread toast, and Add to Summary preserves filter pills", () => {
+ cy.request<GetExplorationDataResponse>(
+ "GET",
+ "/api/exploration/dimensions",
+ ).then(({ body: data }) => {
+ const ordersMetric = data.metrics.find(
+ (metric) => metric.name === ORDERS_COUNT_METRIC_NAME,
+ );
+ expect(
+ ordersMetric,
+ `"${ORDERS_COUNT_METRIC_NAME}" metric is exposed by /api/exploration/dimensions`,
+ ).to.exist;
+ const dimsById = new Map(
+ data.dimension_groups.flatMap((group) =>
+ group.dimensions.map((dim) => [dim.id, dim] as const),
+ ),
+ );
+ const temporalDimension = ordersMetric!.dimension_ids
+ .map((id) => dimsById.get(id))
+ .find((dim) => dim != null && dim.effective_type.includes("Date"));
+ expect(
+ temporalDimension,
+ "orders metric exposes at least one temporal dimension",
+ ).to.exist;
+
+ H.createExplorationViaApi({
+ name: "Chart brush explore-further fixture",
+ metricCardIds: [ordersMetric!.id],
+ dimensionIds: [temporalDimension!.id],
+ }).then((explorationId) => {
+ let initialThreadIds: number[] = [];
+
+ cy.intercept(
+ "POST",
+ `/api/exploration/${explorationId}/explore-further`,
+ ).as("exploreFurther");
+
+ visitExplorationUntilSettled(explorationId, 1);
+
+ cy.request<Exploration>(
+ "GET",
+ `/api/exploration/${explorationId}`,
+ ).then(({ body: exploration }) => {
+ initialThreadIds = (exploration.threads ?? []).map(
+ (thread) => thread.id,
+ );
+ });
+
+ cy.findByTestId("exploration-page-sidebar").within(() => {
+ cy.findByRole("group", { name: ordersMetric!.name }).then(
+ ($group) => {
+ if ($group.attr("aria-expanded") !== "true") {
+ cy.wrap($group).click();
+ }
+ },
+ );
+ cy.findByRole("treeitem", {
+ // Anchor on end so we don't match e.g. "Hour of day".
+ name: new RegExp(`${temporalDimension!.display_name}$`),
+ }).click();
+ });
+
+ H.ensureEchartsContainerHasSvg();
+ H.applyBrush(120, 280);
+
+ cy.findByTestId("click-actions-view").within(() => {
+ cy.findByRole("button", { name: /Explore further/i }).should(
+ "be.visible",
+ );
+ cy.findByRole("button", { name: /Add comment/i }).should("not.exist");
+ });
+
+ cy.findByTestId("click-actions-view")
+ .findByRole("button", { name: /Explore further/i })
+ .click();
+
+ cy.wait("@exploreFurther").then(({ request, response }) => {
+ expect(request.body.explore_filters)
+ .to.be.an("array")
+ .and.have.length(1);
+ expect(request.body.explore_filters[0]).to.include.keys(
+ "operator",
+ "field_ref",
+ "values",
+ "display_value",
+ );
+ expect(request.body.explore_filters[0].operator).to.eq("between");
+ expect(request.body.explore_filters[0].values)
+ .to.be.an("array")
+ .and.have.length(2);
+
+ // Cypress does not type intercept response bodies.
+ const threads = (response?.body as Exploration).threads ?? [];
+ const newThread = threads.find(
+ (thread) => !initialThreadIds.includes(thread.id),
+ );
+ expect(newThread, "explore-further adds a new thread").to.exist;
+ cy.wrap(newThread!.name).as("newThreadName");
+ });
+
+ cy.get<string>("@newThreadName").then((name) => {
+ openExploreFurtherToast(name);
+ });
+
+ cy.location("pathname").should(
+ "include",
+ `/question/research/${explorationId}/page/`,
+ );
+
+ // Temporal ranges use an en-dash (e.g. "Feb 2020 – Mar 2020"); exact
+ // bounds depend on brush pixel coords, so just assert range formatting.
+ cy.findByTestId("filter-pill")
+ .should("be.visible")
+ .invoke("text")
+ .should("match", /–/)
+ .as("exploreFilterPillText");
+
+ cy.intercept(
+ "POST",
+ `/api/exploration/${explorationId}/summary/append`,
+ ).as("appendSummary");
+
+ cy.findByRole("button", { name: "Add to Summary" }).click();
+ cy.wait("@appendSummary");
+
+ H.undoToastListContainer().within(() => {
+ cy.findByText(/Added to/).should("be.visible");
+ cy.findByRole("button", { name: "View" }).click();
+ });
+
+ cy.location("pathname").should(
+ "eq",
+ `/question/research/${explorationId}/summary`,
+ );
+ cy.findByTestId("document-card-embed", { timeout: 15000 })
+ .should("be.visible")
+ .findByTestId("filter-pill")
+ .should("be.visible")
+ .invoke("text")
+ .then((text) => {
+ cy.get("@exploreFilterPillText").should("eq", text);
+ });
+ });
+ });
+ });
+});
+
+describe("scenarios > explorations > Summary document", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ });
+
+ it("auto-creates Summary at the top of the tree, keeps pages selected initially, supports Add to Summary, and mirrors comments both ways", () => {
+ H.createExplorationViaApi({ name: "Summary fixture" }).then(
+ (explorationId) => {
+ cy.request("GET", `/api/exploration/${explorationId}`).then(
+ ({ body }) => {
+ // api returns an Exploration
+ const exploration = body as Exploration;
+ expect(exploration.document, "BE auto-creates a Summary document")
+ .to.exist;
+ expect(exploration.document?.name).to.eq("Summary");
+ expect(exploration.document?.is_placeholder).to.eq(true);
+ },
+ );
+
+ visitExplorationUntilSettled(explorationId, 1);
+
+ // Summary is pinned at the top of the tree but not initially selected
+ // while it is still a placeholder.
+ cy.findAllByRole("treeitem")
+ .first()
+ .should("contain.text", "Summary")
+ .and("have.attr", "aria-selected", "false");
+
+ // Capture the settled page id from the auto-selected sidebar row
+ // (pages only exist after settlement), then click through
+ cy.findAllByRole("treeitem")
+ .filter('[aria-selected="true"]')
+ .should("have.length", 1)
+ .and("not.contain.text", "Summary")
+ .invoke("attr", "href")
+ .should("match", /\/page\/\d+/)
+ .then((href) => {
+ const pageId = Number(/\/page\/(\d+)/.exec(href!)![1]);
+ cy.wrap(pageId).as("pageId");
+ cy.get(`[role="treeitem"][href="${href}"]`).click();
+ });
+
+ cy.location("pathname").should("match", /\/page\/\d+$/);
+ cy.findByTestId("exploration-chart-grid").should("be.visible");
+
+ cy.intercept(
+ "POST",
+ `/api/exploration/${explorationId}/summary/append`,
+ ).as("appendSummary");
+
+ cy.findByRole("button", { name: "Add to Summary" }).click();
+ cy.wait("@appendSummary").then(({ response }) => {
+ expect(response?.statusCode).to.eq(200);
+ expect(response?.body?.is_placeholder).to.eq(false);
+ });
+
+ H.undoToastListContainer()
+ .findByText(/Added to/)
+ .should("be.visible");
+ H.undoToast().findByRole("button", { name: "View" }).click();
+
+ cy.location("pathname").should(
+ "eq",
+ `/question/research/${explorationId}/summary`,
+ );
+ cy.findByTestId("document-card-embed", { timeout: 15000 }).should(
+ "be.visible",
+ );
+
+ // Seed a page comment via API
+ cy.get<number>("@pageId").then((pageId) => {
+ H.createComment({
+ target_type: "exploration",
+ target_id: explorationId,
+ child_target_id: String(pageId),
+ parent_comment_id: null,
+ content: {
+ type: "doc",
+ content: [
+ {
+ type: "paragraph",
+ content: [{ type: "text", text: "Shared comment" }],
+ },
+ ],
+ },
+ });
+ });
+
+ // Cold-load the Summary with the comments query param — the panel
+ // must open without a prior click (the deep-link regression).
+ cy.get<number>("@pageId").then((pageId) => {
+ cy.visit(
+ `/question/research/${explorationId}/summary?comments=${pageId}`,
+ );
+ cy.findByTestId("exploration-summary-comments", {
+ timeout: 15000,
+ })
+ .should("be.visible")
+ .and("contain.text", "Shared comment");
+ });
+
+ cy.get<number>("@pageId").then((pageId) => {
+ cy.visit(
+ `/question/research/${explorationId}/page/${pageId}?comments=${pageId}`,
+ );
+ });
+
+ cy.findByTestId("exploration-comments", { timeout: 15000 }).should(
+ "contain.text",
+ "Shared comment",
+ );
+ },
+ );
+ });
+});
+
+describe("scenarios > explorations > collection placement + archive", () => {
+ beforeEach(() => {
+ cy.task("stopMockLlmServer");
+ H.restore();
+ cy.signInAsAdmin();
+ H.enableExplorations();
+ seedMetrics();
+ H.resetSnowplow();
+ H.enableTracking();
+ });
+
+ afterEach(() => {
+ H.expectNoBadSnowplowEvents();
+ });
+
+ it("places a newly-created exploration in the creator's personal collection and lets the user move it to trash from there", () => {
+ const explorationName = "Personal-collection archive fixture";
+
+ H.createExplorationViaApi({ name: explorationName }).then(
+ (explorationId) => {
+ cy.request("GET", "/api/user/current").then(({ body: user }) => {
+ // Unjustified type cast. FIXME
+ const personalCollectionId = user.personal_collection_id as number;
+ expect(
+ personalCollectionId,
+ "/api/user/current returns a personal collection id",
+ ).to.be.a("number");
+
+ cy.request("GET", `/api/exploration/${explorationId}`).then(
+ ({ body }) => {
+ expect(
+ body.collection_id,
+ "exploration lives in the creator's personal collection",
+ ).to.eq(personalCollectionId);
+ },
+ );
+
+ // Visit the personal collection and confirm the row
+ // renders.
+ H.visitCollection(personalCollectionId);
+ cy.findByTestId("collection-table")
+ .findByText(explorationName)
+ .should("be.visible");
+
+ // Open the row's overflow menu and click `Move to trash`.
+ // Archiving an exploration goes through the centralized
+ // `useSetArchive` hook → `PUT /api/exploration/:id
+ // { archived: true }`.
+ cy.intercept("PUT", `/api/exploration/${explorationId}`).as(
+ "archiveExploration",
+ );
+ H.openCollectionItemMenu(explorationName);
+ // The EntityItem dropdown renders each action as a
+ // `<li aria-labelledby="...">`, not `role="menuitem"`,
+ // so match the visible text — scoped to the open popover.
+ H.popover().findByText("Move to trash").click();
+
+ cy.wait("@archiveExploration").then(({ request, response }) => {
+ expect(request.body).to.deep.eq({ archived: true });
+ expect(response?.statusCode).to.eq(200);
+ });
+
+ // After archive, the collection shows its empty state and
+ // the exploration row is gone from the page.
+ cy.findByText("This collection is empty").should("be.visible");
+ cy.findByText(explorationName).should("not.exist");
+
+ // BE state agrees: a subsequent GET reports
+ // `archived: true`.
+ cy.request("GET", `/api/exploration/${explorationId}`).then(
+ ({ body }) => {
+ expect(body.archived, "exploration is archived").to.eq(true);
+ },
+ );
+
+ H.undoToast().findByText("Trashed research").should("exist");
+ H.undo();
+
+ cy.findByTestId("collection-table")
+ .findByText(explorationName)
+ .should("be.visible");
+ });
+ },
+ );
+ });
+
+ it("permanently deletes an archived exploration via the Delete permanently action on the /trash page", () => {
+ // `ActionMenu`'s `handleDeletePermanently` previously routed
+ // every non-collection model through the legacy entity factory
+ // (`entityForObject`), which has no `explorations` entry — so
+ // the delete crashed. The fix dispatches the RTKQ
+ // `deleteExploration` mutation, which calls
+ // `DELETE /api/exploration/:id` (a new BE endpoint that cascades
+ // through threads/queries/documents via the FK tree).
+ const explorationName = "Trash-page delete-permanently fixture";
+
+ H.createExplorationViaApi({ name: explorationName }).then(
+ (explorationId) => {
+ cy.request("PUT", `/api/exploration/${explorationId}`, {
+ archived: true,
+ });
+
+ cy.visit("/trash");
+ cy.findByTestId("collection-table")
+ .findByText(explorationName)
+ .should("be.visible");
+
+ cy.intercept("DELETE", `/api/exploration/${explorationId}`).as(
+ "deleteExploration",
+ );
+ H.openCollectionItemMenu(explorationName);
+ H.popover().findByText("Delete permanently").click();
+ // The confirmation modal owns the final destructive button.
+ H.modal()
+ .findByRole("button", { name: /Delete permanently/i })
+ .click();
+
+ cy.wait("@deleteExploration")
+ .its("response.statusCode")
+ .should("eq", 204);
+
+ // The row is gone from the trash listing…
+ cy.findByText(explorationName).should("not.exist");
+
+ // …and the BE returns 404 for the now-hard-deleted exploration.
+ cy.request({
+ method: "GET",
+ url: `/api/exploration/${explorationId}`,
+ failOnStatusCode: false,
+ })
+ .its("status")
+ .should("eq", 404);
+ },
+ );
+ });
+
+ it("restores an archived exploration via the Restore action on the /trash page", () => {
+ // `useSetArchive`'s undo toast is one path back, but the trash
+ // page exposes a separate `Restore` action that runs through
+ // `ActionMenu.tsx`'s `handleRestore`. Without an explicit
+ // `exploration` branch in that handler it falls through to the
+ // legacy `entityForObject(...)`, which has no `explorations`
+ // entry — so the restore would silently throw. This test
+ // exercises the dedicated branch end-to-end.
+ const explorationName = "Trash-page restore fixture";
+
+ H.createExplorationViaApi({ name: explorationName }).then(
+ (explorationId) => {
+ // Archive directly via the BE so we land on /trash with the
+ // exploration already in it.
+ cy.request("PUT", `/api/exploration/${explorationId}`, {
+ archived: true,
+ });
+
+ cy.visit("/trash");
+ cy.findByTestId("collection-table")
+ .findByText(explorationName)
+ .should("be.visible");
+
+ cy.intercept("PUT", `/api/exploration/${explorationId}`).as(
+ "restoreExploration",
+ );
+ H.openCollectionItemMenu(explorationName);
+ H.popover().findByText("Restore").click();
+
+ cy.wait("@restoreExploration").then(({ request, response }) => {
+ expect(request.body).to.deep.eq({ archived: false });
+ expect(response?.statusCode).to.eq(200);
+ });
+
+ // The trash listing no longer shows the exploration.
+ cy.findByText(explorationName).should("not.exist");
+
+ // And the BE reports the exploration as un-archived again.
+ cy.request("GET", `/api/exploration/${explorationId}`).then(
+ ({ body }) => {
+ expect(body.archived, "exploration is no longer archived").to.eq(
+ false,
+ );
+ },
+ );
+ },
+ );
+ });
+});
diff --git a/e2e/test/scenarios/onboarding/command-palette.cy.spec.js b/e2e/test/scenarios/onboarding/command-palette.cy.spec.js
index b8ebdc119d2..6812da2d663 100644
--- a/e2e/test/scenarios/onboarding/command-palette.cy.spec.js
+++ b/e2e/test/scenarios/onboarding/command-palette.cy.spec.js
@@ -171,7 +171,7 @@ describe("command palette", () => {
cy.wait(100); // pressing page down too fast does nothing
H.pressPageDown();
H.commandPalette()
- .findByRole("option", { name: "New model" })
+ .findByRole("option", { name: "New collection" })
.should("have.attr", "aria-selected", "true");
H.pressPageDown();
@@ -181,7 +181,7 @@ describe("command palette", () => {
H.pressPageUp();
H.commandPalette()
- .findByRole("option", { name: "New model" })
+ .findByRole("option", { name: "New collection" })
.should("have.attr", "aria-selected", "true");
H.pressPageUp();
diff --git a/enterprise/backend/test/metabase_enterprise/sandbox/explorations_test.clj b/enterprise/backend/test/metabase_enterprise/sandbox/explorations_test.clj
index f98b50f0aca..5a691beae4c 100644
--- a/enterprise/backend/test/metabase_enterprise/sandbox/explorations_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/sandbox/explorations_test.clj
@@ -12,7 +12,6 @@
[metabase-enterprise.sandbox.test-util :as sandbox.tu]
[metabase-enterprise.test :as met]
[metabase.explorations.query-plan.variants :as variants]
- [metabase.explorations.test-util :as explorations.tu]
[metabase.lib.core :as lib]
[metabase.lib.metadata :as lib.metadata]
[metabase.permissions.core :as perms]
@@ -29,9 +28,6 @@
(use-fixtures :once (fixtures/initialize :db :web-server :test-users))
-;; The application does not mount `/api/exploration` while explorations are disabled; serve it for these tests.
-(use-fixtures :each explorations.tu/exploration-routes-fixture)
-
(defn- venues-count-query []
(let [mp (mt/metadata-provider)]
(-> (lib/query mp (lib.metadata/table mp (mt/id :venues)))
diff --git a/frontend/src/metabase/collections/components/CollectionContent/CollectionTypeFilter.unit.spec.tsx b/frontend/src/metabase/collections/components/CollectionContent/CollectionTypeFilter.unit.spec.tsx
index 7b26402dbb7..44f90ed32f2 100644
--- a/frontend/src/metabase/collections/components/CollectionContent/CollectionTypeFilter.unit.spec.tsx
+++ b/frontend/src/metabase/collections/components/CollectionContent/CollectionTypeFilter.unit.spec.tsx
@@ -38,7 +38,14 @@ describe("CollectionTypeFilter", () => {
it("shows every type in display order, disabling those without items", async () => {
setup({
- availableModels: ["metric", "card", "collection", "dataset", "dashboard"],
+ availableModels: [
+ "metric",
+ "card",
+ "collection",
+ "dataset",
+ "dashboard",
+ "exploration",
+ ],
});
const filterButton = screen.getByTestId("collection-type-filter-button");
@@ -56,6 +63,7 @@ describe("CollectionTypeFilter", () => {
"Question",
"Metric",
"Document",
+ "Research",
"Table",
];
expect(checkboxes).toHaveLength(TYPE_FILTER_MODELS.length);
@@ -65,7 +73,7 @@ describe("CollectionTypeFilter", () => {
for (const label of labels) {
expect(screen.getByLabelText(label)).not.toBeChecked();
}
- for (const label of ["Collection", "Dashboard", "Metric"]) {
+ for (const label of ["Collection", "Dashboard", "Metric", "Research"]) {
expect(screen.getByLabelText(label)).toBeEnabled();
}
expect(screen.getByLabelText("Document")).toBeDisabled();
diff --git a/frontend/src/metabase/collections/components/CollectionContent/constants.ts b/frontend/src/metabase/collections/components/CollectionContent/constants.ts
index c42f86019ac..c6700eee0b2 100644
--- a/frontend/src/metabase/collections/components/CollectionContent/constants.ts
+++ b/frontend/src/metabase/collections/components/CollectionContent/constants.ts
@@ -20,6 +20,7 @@ export const ALL_MODELS: CollectionItemModel[] = [
"collection",
"document",
"table",
+ "exploration",
];
export const TYPE_FILTER_MODELS = [
@@ -29,5 +30,6 @@ export const TYPE_FILTER_MODELS = [
"card",
"metric",
"document",
+ "exploration",
"table",
] as const satisfies readonly CollectionItemModel[];
diff --git a/frontend/src/metabase/metabot/components/MetabotAsk/MetabotGreeting.tsx b/frontend/src/metabase/metabot/components/MetabotAsk/MetabotGreeting.tsx
index 817a7d6217d..2fd473e849b 100644
--- a/frontend/src/metabase/metabot/components/MetabotAsk/MetabotGreeting.tsx
+++ b/frontend/src/metabase/metabot/components/MetabotAsk/MetabotGreeting.tsx
@@ -3,6 +3,7 @@ import { useState } from "react";
import { t } from "ttag";
import _ from "underscore";
+import { ForwardRefLink } from "metabase/common/components/Link";
import { AIProviderConfigurationModal } from "metabase/metabot/components/AIProviderConfigurationModal";
import { AIProviderConfigurationNotice } from "metabase/metabot/components/AIProviderConfigurationNotice";
import { MetabotPromptInput } from "metabase/metabot/components/MetabotPromptInput";
@@ -14,6 +15,7 @@ import type { SuggestionModel } from "metabase/rich_text_editing/tiptap/extensio
import {
ActionIcon,
Box,
+ Button,
Flex,
Icon,
Paper,
@@ -21,6 +23,7 @@ import {
Text,
UnstyledButton,
} from "metabase/ui";
+import * as Urls from "metabase/urls";
import { useGetSuggestedMetabotPromptsQuery } from "../../api";
@@ -77,6 +80,14 @@ export const MetabotGreeting = ({
<Text fz="xl" fw={600} c="text-primary">
{title}
</Text>
+ <Button
+ component={ForwardRefLink}
+ to={Urls.newExploration()}
+ bd="none"
+ leftSection={<Icon name="telescope" c="brand" />}
+ >
+ {t`Research`}
+ </Button>
</Flex>
<Paper className={S.inputContainer}>
<Box className={S.editorWrapper}>
diff --git a/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.tsx b/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.tsx
index 15a9470747f..bafcec1a81c 100644
--- a/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.tsx
+++ b/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.tsx
@@ -7,16 +7,20 @@ import type { CollectionId } from "metabase-types/api";
interface NewMenuItemAIExplorationProps {
collectionId?: CollectionId;
+ hasNlqAccess?: boolean;
}
export function NewMenuItemAIExploration({
collectionId,
+ hasNlqAccess,
}: NewMenuItemAIExplorationProps) {
- const url = Urls.newQuestion({
- mode: "ask",
- collectionId,
- cardType: "question",
- });
+ const url = hasNlqAccess
+ ? Urls.newQuestion({
+ mode: "ask",
+ collectionId,
+ cardType: "question",
+ })
+ : Urls.newExploration();
return (
<Menu.Item
diff --git a/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.unit.spec.tsx b/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.unit.spec.tsx
index f25f1c14955..28e381bea14 100644
--- a/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.unit.spec.tsx
+++ b/frontend/src/metabase/metabot/components/NewMenuItemAIExploration.unit.spec.tsx
@@ -7,11 +7,15 @@ import { Menu } from "metabase/ui";
import { NewMenuItemAIExploration } from "./NewMenuItemAIExploration";
-function setup() {
+function setup(
+ { hasNlqAccess } = {
+ hasNlqAccess: true,
+ },
+) {
const TestComponent = () => (
<Menu opened>
<Menu.Dropdown>
- <NewMenuItemAIExploration />
+ <NewMenuItemAIExploration hasNlqAccess={hasNlqAccess} />
</Menu.Dropdown>
</Menu>
);
@@ -29,11 +33,21 @@ function setup() {
}
describe("NewMenuItemAIExploration", () => {
- it("links to the ask mode question page", () => {
+ it("links to the ask mode question page when hasNlqAccess is true", () => {
setup();
expect(
screen.getByRole("menuitem", { name: /AI exploration/ }),
).toHaveAttribute("href", "/question/ask");
});
+
+ it("should link to the research mode page when hasNlqAccess is false", () => {
+ setup({
+ hasNlqAccess: false,
+ });
+
+ expect(
+ screen.getByRole("menuitem", { name: /AI exploration/ }),
+ ).toHaveAttribute("href", "/question/research");
+ });
});
diff --git a/frontend/src/metabase/nav/components/NewItemMenu/NewItemMenuView.tsx b/frontend/src/metabase/nav/components/NewItemMenu/NewItemMenuView.tsx
index 035b5867f70..f3e392d2cc1 100644
--- a/frontend/src/metabase/nav/components/NewItemMenu/NewItemMenuView.tsx
+++ b/frontend/src/metabase/nav/components/NewItemMenu/NewItemMenuView.tsx
@@ -47,9 +47,13 @@ export const NewItemMenuView = ({
const menuItems = useMemo(() => {
const items = [];
- if (hasDataAccess && hasNlqAccess) {
+ if (hasDataAccess) {
items.push(
- <NewMenuItemAIExploration key="nlq" collectionId={collectionId} />,
+ <NewMenuItemAIExploration
+ key="nlq"
+ collectionId={collectionId}
+ hasNlqAccess={hasNlqAccess}
+ />,
);
}
diff --git a/frontend/src/metabase/palette/hooks/useCommandPaletteBasicActions.tsx b/frontend/src/metabase/palette/hooks/useCommandPaletteBasicActions.tsx
index 42c889dddeb..64bbbb40693 100644
--- a/frontend/src/metabase/palette/hooks/useCommandPaletteBasicActions.tsx
+++ b/frontend/src/metabase/palette/hooks/useCommandPaletteBasicActions.tsx
@@ -41,6 +41,7 @@ import {
export const BASIC_ACTION_ORDER = [
"create-new-question",
"create-new-native-query",
+ "create-new-research",
"create-new-dashboard",
"create-new-document",
"create-new-collection",
@@ -157,6 +158,19 @@ export const useCommandPaletteBasicActions = ({
});
}
+ if (hasDataAccess) {
+ actions.push({
+ id: "create-new-research",
+ name: t`New research`,
+ section: "basic",
+ icon: "telescope",
+ perform: () => {
+ dispatch(closeModal());
+ navigate(Urls.newExploration());
+ },
+ });
+ }
+
actions.push({
id: "create-new-dashboard",
name: t`New dashboard`,
diff --git a/frontend/src/metabase/palette/shortcuts/global.ts b/frontend/src/metabase/palette/shortcuts/global.ts
index 3bb8da8c2ab..1ff2d7ef720 100644
--- a/frontend/src/metabase/palette/shortcuts/global.ts
+++ b/frontend/src/metabase/palette/shortcuts/global.ts
@@ -21,6 +21,16 @@ export const globalShortcuts = {
shortcut: ["c n"],
shortcutGroup: "global" as const,
},
+ "create-new-research": {
+ get name() {
+ return t`Create a research`;
+ },
+ get keywords() {
+ return t`add research, add exploration, research mode`;
+ },
+ shortcut: ["c r"],
+ shortcutGroup: "global" as const,
+ },
"create-new-dashboard": {
get name() {
return t`Create a dashboard`;
diff --git a/frontend/src/metabase/routes.tsx b/frontend/src/metabase/routes.tsx
index 719752de4e8..be99f92d14c 100644
--- a/frontend/src/metabase/routes.tsx
+++ b/frontend/src/metabase/routes.tsx
@@ -20,6 +20,7 @@ import { MoveQuestionsIntoDashboardsModal } from "metabase/common/components/Mov
import { NotFoundFallbackPage } from "metabase/common/components/NotFoundFallbackPage";
import { UnsubscribePage } from "metabase/common/components/Unsubscribe";
import { getDataStudioRoutes } from "metabase/data-studio/routes";
+import { getRoutes as getExplorationsRoutes } from "metabase/explorations/routes";
import { getMetabotRoutes } from "metabase/metabot/routes";
import { getMetricRoutes } from "metabase/metrics/routes";
import NewModelOptions from "metabase/models/containers/NewModelOptions";
@@ -444,8 +445,7 @@ export const getRoutes = (store: AppStore): RouteObject[] => [
{ index: true, lazy: queryBuilder },
{ path: "notebook", lazy: queryBuilder },
{ path: "ask", lazy: metabotQueryBuilder },
- // Explorations are intentionally disabled on the v64 release branch. do not uncomment this
- // ...toRouteObjects(getExplorationsRoutes()),
+ ...toRouteObjects(getExplorationsRoutes()),
{ path: ":slug", lazy: queryBuilder },
{ path: ":slug/notebook", lazy: queryBuilder },
{ path: ":slug/metabot", lazy: queryBuilder },
diff --git a/src/metabase/api_routes/routes.clj b/src/metabase/api_routes/routes.clj
index 0406ffcf262..a30b83e4bf3 100644
--- a/src/metabase/api_routes/routes.clj
+++ b/src/metabase/api_routes/routes.clj
@@ -28,6 +28,7 @@
[metabase.documents.api]
[metabase.eid-translation.api]
[metabase.embedding-rest.api]
+ [metabase.explorations.api]
[metabase.frontend-errors.api]
[metabase.geojson.api]
[metabase.glossary.api]
@@ -97,6 +98,7 @@
metabase.data-studio.api/keep-me
metabase.documents.api/keep-me
metabase.eid-translation.api/keep-me
+ metabase.explorations.api/keep-me
metabase.frontend-errors.api/keep-me
metabase.geojson.api/keep-me
metabase.glossary.api/keep-me
@@ -206,8 +208,7 @@
"/embed-mcp" (+auth metabase.mcp.callback-api/routes)
"/embed-theme" (+auth metabase.embedding-rest.api/theme-routes)
"/eval-trace" (metabase.ai-tracing.api/+eval-capture-enabled metabase.ai-tracing.api/routes)
- ;; Explorations are intentionally disabled on the v64 release branch. do not uncomment this
- ;; "/exploration" (+auth metabase.explorations.api/routes)
+ "/exploration" (+auth metabase.explorations.api/routes)
"/field" (+auth metabase.warehouse-schema-rest.api/field-routes)
"/frontend-errors" metabase.frontend-errors.api/routes
"/geojson" 'metabase.geojson.api
diff --git a/src/metabase/bookmarks/api.clj b/src/metabase/bookmarks/api.clj
index 580335b4138..93e85829840 100644
--- a/src/metabase/bookmarks/api.clj
+++ b/src/metabase/bookmarks/api.clj
@@ -14,7 +14,7 @@
(def Models
"Schema enumerating bookmarkable models."
(into [:enum]
- ["card" "dashboard" "collection" "document"]))
+ ["card" "dashboard" "collection" "document" "exploration"]))
(def BookmarkOrderings
"Schema for an ordered of bookmark orderings"
diff --git a/src/metabase/bookmarks/db.clj b/src/metabase/bookmarks/db.clj
index 1505b62c89b..3ef8e5118f7 100644
--- a/src/metabase/bookmarks/db.clj
+++ b/src/metabase/bookmarks/db.clj
@@ -207,9 +207,17 @@
:created_at]
:from [:document_bookmark]
:where [:= :user_id user-id]}]]
- ;; While explorations are disabled, `exploration_bookmark` is left out of the union so residue rows never reach
- ;; the listing. The `exploration_id` column stays so the joins in [[bookmark-rows-for-user]] resolve.
- {:union-all base-queries}))
+ {:union-all (conj base-queries
+ ^:allow-subquery {:select [[as-null :card_id]
+ [as-null :dashboard_id]
+ [as-null :collection_id]
+ [as-null :document_id]
+ :exploration_id
+ [:exploration_id :item_id]
+ [(h2x/literal "exploration") :type]
+ :created_at]
+ :from [:exploration_bookmark]
+ :where [:= :user_id user-id]})}))
(mr/def ::bookmark-row
"A bookmark row left joined against the Card, Dashboard, Collection, Document, and Exploration tables."
diff --git a/src/metabase/collections/children.clj b/src/metabase/collections/children.clj
index 29d7ccf1a7f..5b41e58af35 100644
--- a/src/metabase/collections/children.clj
+++ b/src/metabase/collections/children.clj
@@ -161,6 +161,7 @@
#{"card" ; SavedQuestion
"dataset" ; Model. TODO : update this
"document"
+ "exploration"
"metric"
"collection"
"dashboard"
@@ -1131,7 +1132,7 @@
(defn- valid-collection-models
"Return every item model that can appear in `collection-namespace`."
[collection-namespace]
- (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document :transform]
+ (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document :exploration :transform]
;; Tables in collections are an EE feature (library)
(premium-features/has-feature? :library) (conj :table))
:let [toucan-model (model-name->toucan-model model-kw)
@@ -1144,7 +1145,7 @@
"Fetch a sequence of 'child' objects belonging to a Collection, filtered using `options`."
[{collection-namespace :namespace, :as collection} :- collection/CollectionWithLocationAndIDOrRoot
{:keys [models created-by-id], :as options} :- CollectionChildrenOptions]
- (let [valid-models (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document :transform]
+ (let [valid-models (for [model-kw (cond-> [:collection :dataset :metric :card :dashboard :pulse :snippet :timeline :document :exploration :transform]
;; Tables in collections are an EE feature (library)
(premium-features/has-feature? :library) (conj :table))
;; only fetch models that are specified by the `model` param; or everything if it's empty
diff --git a/src/metabase/comments/api.clj b/src/metabase/comments/api.clj
index c79ce0d57d6..28ea5ca6e6d 100644
--- a/src/metabase/comments/api.clj
+++ b/src/metabase/comments/api.clj
@@ -22,9 +22,8 @@
[toucan2.core :as t2]))
(def ^:private type->model
- ;; While explorations are disabled, leaving the type out rejects exploration targets, since [[TargetType]] derives
- ;; from these keys.
- {"document" :model/Document})
+ {"document" :model/Document
+ "exploration" :model/Exploration})
(def ^:private TargetType
"Malli enum of valid comment target types, derived from [[type->model]]."
diff --git a/src/metabase/metabot/agent/profiles.clj b/src/metabase/metabot/agent/profiles.clj
index db923e781f8..e8db96b1e93 100644
--- a/src/metabase/metabot/agent/profiles.clj
+++ b/src/metabase/metabot/agent/profiles.clj
@@ -214,26 +214,23 @@
#'tools/create-alert-tool
#'tools/slackbot-create-dashboard-subscription-tool]})
-(def explorations-profile
- "The `:explorations` (Research mode) profile. Explorations are intentionally disabled on the v64 release branch,
- so this profile is defined but not registered; do not register it here. Tests that exercise it register it with
- [[metabase.metabot.test-util/do-with-registered-profile!]]."
- {:name :explorations
- :prompt-template "explorations.selmer"
- :max-iterations 15
- :temperature 0.3
- :system-prompt-context #'tools.explorations/research-plan-system-context
- :skills? false
- :tools [#'tools/search-tool
- #'tools/read-resource-tool
- #'tools/list-research-metrics-tool
- #'tools/get-research-candidates-tool
- #'tools/add-research-groups-tool
- #'tools/remove-from-research-plan-tool
- #'tools/set-exploration-name-tool
- #'tools/list-timelines-tool
- #'tools/get-timeline-details-tool
- #'tools/select-exploration-timelines-tool]})
+(register-profile!
+ {:name :explorations
+ :prompt-template "explorations.selmer"
+ :max-iterations 15
+ :temperature 0.3
+ :system-prompt-context #'tools.explorations/research-plan-system-context
+ :skills? false
+ :tools [#'tools/search-tool
+ #'tools/read-resource-tool
+ #'tools/list-research-metrics-tool
+ #'tools/get-research-candidates-tool
+ #'tools/add-research-groups-tool
+ #'tools/remove-from-research-plan-tool
+ #'tools/set-exploration-name-tool
+ #'tools/list-timelines-tool
+ #'tools/get-timeline-details-tool
+ #'tools/select-exploration-timelines-tool]})
(defn- filter-by-capabilities
"Filter tool vars by user capabilities.
diff --git a/src/metabase/search/config.clj b/src/metabase/search/config.clj
index 4cf2eaa1ad1..a647915acbd 100644
--- a/src/metabase/search/config.clj
+++ b/src/metabase/search/config.clj
@@ -50,9 +50,6 @@
#{"dashboard-card"
"dashboard-tab"
"dimension"
- ;; While explorations are disabled. Residue rows (from an instance that was upgraded, used explorations, then
- ;; downgraded) are still ingested, so excluding the model here filters them out at query time.
- "exploration"
"permissions-group"
"pulse"
"pulse-card"
@@ -81,8 +78,7 @@
(def models-search-order
"The order of this list influences the order of the results: items earlier in the
list will be ranked higher."
- ["dashboard" "metric" "segment" "measure" "indexed-entity" "card" "dataset" "collection" "table" "action" "document"
- "transform" "database"])
+ ["dashboard" "metric" "segment" "measure" "indexed-entity" "card" "dataset" "collection" "table" "action" "document" "exploration" "transform" "database"])
(assert (= all-models (set models-search-order)) "The models search order has to include all models")
diff --git a/test/metabase/bookmarks/api_test.clj b/test/metabase/bookmarks/api_test.clj
index bbfa3c6b341..c80f20da11a 100644
--- a/test/metabase/bookmarks/api_test.clj
+++ b/test/metabase/bookmarks/api_test.clj
@@ -120,13 +120,16 @@
(mt/with-temp [:model/Collection {coll-id :id :as coll} {:name "Readable"}
:model/Card {card-id :id} {:name "Secret Card" :collection_id coll-id}
:model/Dashboard {dash-id :id} {:name "Secret Dashboard" :collection_id coll-id}
- :model/Document {doc-id :id} {:name "Secret Document" :collection_id coll-id}]
+ :model/Document {doc-id :id} {:name "Secret Document" :collection_id coll-id}
+ :model/Exploration {expl-id :id} {:name "Secret Exploration" :collection_id coll-id}]
(perms/grant-collection-read-permissions! (perms/all-users-group) coll)
;; rasta bookmarks each item (including the collection itself) while access is granted; POST read-check passes.
- (doseq [[model id] [["card" card-id] ["dashboard" dash-id] ["document" doc-id] ["collection" coll-id]]]
+ (doseq [[model id] [["card" card-id] ["dashboard" dash-id] ["document" doc-id]
+ ["exploration" expl-id] ["collection" coll-id]]]
(mt/user-http-request :rasta :post 200 (format "bookmark/%s/%d" model id)))
(testing "happy path: all bookmarks are visible while access is granted"
- (is (= #{["card" card-id] ["dashboard" dash-id] ["document" doc-id] ["collection" coll-id]}
+ (is (= #{["card" card-id] ["dashboard" dash-id] ["document" doc-id]
+ ["exploration" expl-id] ["collection" coll-id]}
(bookmarked-items :rasta))))
(testing "after revoking read access (nothing archived), none of the bookmarks are returned"
(perms/revoke-collection-permissions! (perms/all-users-group) coll)
@@ -139,17 +142,19 @@
:model/Collection {hidden-id :id} {:name "Hidden"}
:model/Card {card-id :id} {:name "Secret Card" :collection_id readable-id}
:model/Dashboard {dash-id :id} {:name "Secret Dashboard" :collection_id readable-id}
- :model/Document {doc-id :id} {:name "Secret Document" :collection_id readable-id}]
+ :model/Document {doc-id :id} {:name "Secret Document" :collection_id readable-id}
+ :model/Exploration {expl-id :id} {:name "Secret Exploration" :collection_id readable-id}]
(perms/grant-collection-read-permissions! (perms/all-users-group) readable)
- (doseq [[model id] [["card" card-id] ["dashboard" dash-id] ["document" doc-id]]]
+ (doseq [[model id] [["card" card-id] ["dashboard" dash-id] ["document" doc-id] ["exploration" expl-id]]]
(mt/user-http-request :rasta :post 200 (format "bookmark/%s/%d" model id)))
- (is (= #{["card" card-id] ["dashboard" dash-id] ["document" doc-id]}
+ (is (= #{["card" card-id] ["dashboard" dash-id] ["document" doc-id] ["exploration" expl-id]}
(bookmarked-items :rasta)))
(testing "moving each item into an unreadable collection (admin action; nothing archived) hides its bookmark"
;; stand in for the admin PUT /api/card|document ... {:collection_id hidden} in the attack
(t2/update! :model/Card card-id {:collection_id hidden-id})
(t2/update! :model/Dashboard dash-id {:collection_id hidden-id})
(t2/update! :model/Document doc-id {:collection_id hidden-id})
+ (t2/update! :model/Exploration expl-id {:collection_id hidden-id})
(is (= #{} (bookmarked-items :rasta))))))))
(deftest bookmark-card-type-tracks-current-card-type-test
@@ -277,3 +282,42 @@
(testing "archived documents don't appear in bookmark list"
(is (empty? (filter #(= (:type %) "document")
(mt/user-http-request :rasta :get 200 "bookmark"))))))))
+
+(deftest exploration-bookmarks-test
+ (testing "Exploration bookmarks"
+ (mt/with-temp [:model/Collection {coll-id :id} {:name "Test Collection"}
+ :model/Exploration exploration {:name "Test Exploration" :collection_id coll-id}]
+ (testing "can bookmark an exploration"
+ (is (= (u/the-id exploration)
+ (->> (mt/user-http-request :rasta :post 200 (str "bookmark/exploration/" (u/the-id exploration)))
+ :exploration_id))))
+ (testing "exploration appears in bookmark list"
+ (let [result (mt/user-http-request :rasta :get 200 "bookmark")
+ exploration-bookmark (first (filter #(= (:type %) "exploration") result))]
+ (is (some? exploration-bookmark))
+ (is (= "Test Exploration" (:name exploration-bookmark)))
+ (is (= (u/the-id exploration) (:item_id exploration-bookmark)))))
+ (testing "can delete exploration bookmark"
+ (mt/user-http-request :rasta :delete 204 (str "bookmark/exploration/" (u/the-id exploration)))
+ (is (empty? (filter #(= (:type %) "exploration")
+ (mt/user-http-request :rasta :get 200 "bookmark")))))
+ (testing "exploration bookmarks are included in ordering"
+ (mt/with-temp [:model/Card card {:name "Test Card"}]
+ (mt/with-model-cleanup [:model/BookmarkOrdering]
+ (bookmark-models (mt/user->id :rasta) exploration card)
+ (mt/user-http-request :rasta :put 204 "bookmark/ordering"
+ {:orderings [{:type "exploration" :item_id (u/the-id exploration)}
+ {:type "card" :item_id (u/the-id card)}]})
+ (is (= ["exploration" "card"]
+ (map :type (mt/user-http-request :rasta :get 200 "bookmark"))))))))))
+
+(deftest exploration-bookmarks-archived-test
+ (testing "Exploration bookmarks on archived explorations"
+ (mt/with-temp [:model/Collection {coll-id :id} {:name "Test Collection"}
+ :model/Exploration archived-exploration {:name "Archived Exploration"
+ :collection_id coll-id
+ :archived true}]
+ (bookmark-models (mt/user->id :rasta) archived-exploration)
+ (testing "archived explorations don't appear in bookmark list"
+ (is (empty? (filter #(= (:type %) "exploration")
+ (mt/user-http-request :rasta :get 200 "bookmark"))))))))
diff --git a/test/metabase/collections_rest/api_test.clj b/test/metabase/collections_rest/api_test.clj
index 39853ed71a6..3d524948dc3 100644
--- a/test/metabase/collections_rest/api_test.clj
+++ b/test/metabase/collections_rest/api_test.clj
@@ -1063,6 +1063,20 @@
(is (= #{["card" "Question"]}
(set (map (juxt :model :name) (:data models-response)))))))))))
+(deftest collection-items-available-models-exploration-test
+ (testing "GET /api/collection/:id/items"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection collection {}
+ :model/Card _ {:name "Question" :collection_id (u/the-id collection)}
+ :model/Exploration _ {:name "Exploration"
+ :creator_id (u/the-id owner)
+ :collection_id (u/the-id collection)}]
+ (testing "reports explorations so they can be filtered on"
+ (let [response (mt/user-http-request :crowberto :get 200
+ (str "collection/" (u/the-id collection) "/items")
+ :include-available-models true)]
+ (is (= ["card" "exploration"] (:available_models response))))))))
+
(deftest collection-items-metadata-test
(testing "GET /api/collection/:id/items/metadata"
(mt/with-temp [:model/Collection collection {}
@@ -3987,3 +4001,162 @@
(is (= "You don't have permissions to do that."
(mt/user-http-request :rasta :put 403 (str "collection/" (u/the-id archived-collection))
{:archived false :parent_id (u/the-id dest-collection)}))))))))
+
+(defn- exploration-items-in [coll-id & {:keys [user] :or {user :crowberto}}]
+ (->> (:data (mt/user-http-request user :get 200 (str "collection/" coll-id "/items")))
+ (filter #(= "exploration" (:model %)))))
+
+(deftest explorations-appear-in-collection-items-test
+ (testing "GET /api/collection/:id/items"
+ (testing "explorations in a shared collection appear in that collection's items"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {}
+ :model/Exploration e {:name "Shared Expl"
+ :creator_id (:id owner)
+ :collection_id (:id coll)}]
+ (let [items (exploration-items-in (:id coll))]
+ (is (= [{:id (:id e) :name "Shared Expl" :model "exploration"}]
+ (map #(select-keys % [:id :name :model]) items))))))
+ (testing "?model=exploration filters to only explorations"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {}
+ :model/Card _card {:collection_id (:id coll)}
+ :model/Exploration e {:name "Just me"
+ :creator_id (:id owner)
+ :collection_id (:id coll)}]
+ (let [items (:data (mt/user-http-request :crowberto :get 200
+ (str "collection/" (:id coll) "/items?models=exploration")))]
+ (is (= [{:id (:id e) :model "exploration"}]
+ (map #(select-keys % [:id :model]) items))))))))
+
+(deftest exploration-respects-collection-perms-test
+ (testing "Users without read on the exploration's collection don't see it in /items"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {:name "Locked"}
+ :model/Exploration e {:name "Hidden"
+ :creator_id (:id owner)
+ :collection_id (:id coll)}]
+ (perms/revoke-collection-permissions! (perms/all-users-group) coll)
+ (testing "rasta cannot see the exploration"
+ (let [resp (mt/user-http-request :rasta :get (str "collection/" (:id coll) "/items"))]
+ ;; Either the collection itself is forbidden (403) or the items list omits the exploration.
+ (cond
+ (= 403 (:status-code resp)) (is true)
+ :else (is (not (some #(= (:id e) (:id %)) (filter #(= "exploration" (:model %)) (:data resp))))))))
+ (testing "after granting read, the exploration appears"
+ (perms/grant-collection-read-permissions! (perms/all-users-group) coll)
+ (let [items (exploration-items-in (:id coll) :user :rasta)]
+ (is (some #(= (:id e) (:id %)) items)))))))
+
+(deftest exploration-trash-and-archive-directly-test
+ (testing "Directly-archived exploration appears in /collection/trash/items"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {}
+ :model/Exploration e {:name "Tossed"
+ :creator_id (:id owner)
+ :collection_id (:id coll)
+ :archived true
+ :archived_directly true}]
+ (let [items (->> (:data (mt/user-http-request :crowberto :get 200
+ (format "collection/%d/items" (collection/trash-collection-id))))
+ (filter #(= "exploration" (:model %))))]
+ (is (some #(= (:id e) (:id %)) items)))))
+ (testing "Cascade-archived (archived=true, archived_directly=false) does not appear in trash"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {}
+ :model/Exploration e {:name "Cascade"
+ :creator_id (:id owner)
+ :collection_id (:id coll)
+ :archived true
+ :archived_directly false}]
+ (let [items (->> (:data (mt/user-http-request :crowberto :get 200
+ (format "collection/%d/items" (collection/trash-collection-id))))
+ (filter #(= "exploration" (:model %))))]
+ (is (not (some #(= (:id e) (:id %)) items)))))))
+
+(deftest exploration-pinning-test
+ (testing "explorations with collection_position appear under ?pinned-state=is_pinned"
+ (mt/with-temp [:model/User owner {}
+ :model/Collection coll {}
+ :model/Exploration pinned {:name "Pinned"
+ :creator_id (:id owner)
+ :collection_id (:id coll)
+ :collection_position 1}
+ :model/Exploration unpinned {:name "Unpinned"
+ :creator_id (:id owner)
+ :collection_id (:id coll)}]
+ (let [pinned-items (->> (:data (mt/user-http-request :crowberto :get 200
+ (str "collection/" (:id coll) "/items?pinned-state=is_pinned")))
+ (filter #(= "exploration" (:model %)))
+ (map :id)
+ set)]
+ (is (contains? pinned-items (:id pinned)))
+ (is (not (contains? pinned-items (:id unpinned))))))))
+
+(defn- find-exploration [items expl-id]
+ (some #(when (and (= "exploration" (:model %)) (= expl-id (:id %))) %) items))
+
+(deftest exploration-last-edit-info-test
+ (testing "GET /api/collection/:id/items reports last-edit-info for explorations"
+ (testing "freshly created exploration with a creation revision -> last-edit-info populated"
+ (mt/with-temp [:model/Collection coll {}
+ :model/Exploration e {:name "Created"
+ :creator_id (mt/user->id :crowberto)
+ :collection_id (:id coll)}]
+ (revision/push-revision! {:entity :model/Exploration
+ :id (:id e)
+ :object (t2/select-one :model/Exploration :id (:id e))
+ :user-id (mt/user->id :crowberto)
+ :is-creation? true})
+ (let [item (find-exploration (:data (mt/user-http-request :crowberto :get 200
+ (str "collection/" (:id coll) "/items")))
+ (:id e))]
+ (is (some? item))
+ (is (= (mt/user->id :crowberto)
+ (-> item :last-edit-info :id))))))
+ (testing "no Exploration or Document revisions -> last-edit-info absent"
+ (mt/with-temp [:model/Collection coll {}
+ :model/Exploration e {:name "Bare"
+ :creator_id (mt/user->id :crowberto)
+ :collection_id (:id coll)}]
+ (let [item (find-exploration (:data (mt/user-http-request :crowberto :get 200
+ (str "collection/" (:id coll) "/items")))
+ (:id e))]
+ (is (some? item))
+ (is (nil? (:last-edit-info item))))))
+ (testing "Document attached to an exploration bumps the exploration's last-edit-info"
+ (mt/with-temp [:model/Collection coll {}
+ :model/Exploration e {:name "DocBumped"
+ :creator_id (mt/user->id :crowberto)
+ :collection_id (:id coll)}
+ :model/Document doc {:name "notes"
+ :collection_id (:id coll)
+ :creator_id (mt/user->id :crowberto)
+ :exploration_id (:id e)
+ :document {:type "doc" :content []}}]
+ ;; Older Exploration revision by :crowberto, newer Document revision by :rasta.
+ ;; Insert directly so we control timestamps — within a `with-temp` transaction
+ ;; the DB-side NOW() is frozen, so the standard push-revision! path would emit
+ ;; identical timestamps and tiebreak non-deterministically.
+ (let [t (java.time.OffsetDateTime/now)]
+ (t2/insert! :model/Revision
+ {:model "Exploration"
+ :model_id (:id e)
+ :user_id (mt/user->id :crowberto)
+ :object (revision/serialize-instance :model/Exploration (:id e)
+ (t2/select-one :model/Exploration :id (:id e)))
+ :timestamp (.minusSeconds t 60)
+ :is_creation true})
+ (t2/insert! :model/Revision
+ {:model "Document"
+ :model_id (:id doc)
+ :user_id (mt/user->id :rasta)
+ :object (revision/serialize-instance :model/Document (:id doc)
+ (t2/select-one :model/Document :id (:id doc)))
+ :timestamp t}))
+ (let [item (find-exploration (:data (mt/user-http-request :crowberto :get 200
+ (str "collection/" (:id coll) "/items")))
+ (:id e))]
+ (is (some? item))
+ (is (= (mt/user->id :rasta)
+ (-> item :last-edit-info :id))))))))
diff --git a/test/metabase/explorations/api_test.clj b/test/metabase/explorations/api_test.clj
index bfd06030fd9..b02622b226a 100644
--- a/test/metabase/explorations/api_test.clj
+++ b/test/metabase/explorations/api_test.clj
@@ -14,7 +14,6 @@
[metabase.explorations.query-plan.context :as qp.context]
[metabase.explorations.query-plan.variants :as qp.variants]
[metabase.explorations.queues :as explorations.queues]
- [metabase.explorations.test-util :as explorations.tu]
[metabase.lib-be.metadata.jvm :as lib-be]
[metabase.lib.core :as lib]
[metabase.lib.metadata :as lib.metadata]
@@ -30,9 +29,6 @@
(use-fixtures :once (fixtures/initialize :db :web-server :test-users))
-;; The application does not mount `/api/exploration` while explorations are disabled; serve it for these tests.
-(use-fixtures :each explorations.tu/exploration-routes-fixture)
-
(deftest gate-threads-derived-data-forbidden-status-test
(testing "gate-threads-derived-data stamps forbidden when derived data is not visible"
(let [gate #'metabase.explorations.api/gate-threads-derived-data
diff --git a/test/metabase/explorations/derived_perms_test.clj b/test/metabase/explorations/derived_perms_test.clj
index 4464f7ad436..f36aa1b67b5 100644
--- a/test/metabase/explorations/derived_perms_test.clj
+++ b/test/metabase/explorations/derived_perms_test.clj
@@ -5,8 +5,6 @@
the batching that must not merge snapshots requiring different permissions."
(:require
[clojure.test :refer :all]
- [metabase.comments.db :as comments.db]
- [metabase.comments.models.comment :as comment]
[metabase.documents.core :as documents]
[metabase.explorations.derived-perms :as derived-perms]
[metabase.lib.core :as lib]
@@ -380,14 +378,12 @@
:join [[:exploration_block :b] [:= :b.id :p.exploration_block_id]]
:where [:= :b.exploration_thread_id thread-id]}))
-(defn- comment-contexts
- "The contexts of the comments on `exploration-id` as `user-kw` sees them. The comments API rejects exploration
- targets while explorations are disabled, so this runs the registered gate over the rows the way its GET does."
- [exploration-id user-kw]
- (request/with-current-user (mt/user->id user-kw)
- (->> (comments.db/comments-for-target "exploration" exploration-id)
- (comment/apply-context-gate "exploration" exploration-id)
- (mapv :context))))
+(defn- comment-contexts [exploration-id user-kw]
+ (->> (mt/user-http-request user-kw :get 200 "comment/"
+ :target_type "exploration"
+ :target_id exploration-id)
+ :comments
+ (mapv :context)))
(deftest exploration-comment-context-is-gated-test
(testing "a comment anchored to a chart point of an exploration the viewer is gated out of"
@@ -399,24 +395,24 @@
;; by the data-access gate rather than by collection permissions.
(t2/update! :model/Exploration expl-id {:collection_id coll-id})
(perms/grant-collection-read-permissions! (perms-group/all-users) coll-id)
- (mt/with-temp [:model/Comment _ {:target_type "exploration"
- :target_id expl-id
- :child_target_id (str page-id)
- :creator_id (mt/user->id :lucky)
- :content {:type "doc" :content []}
- :context {:highlighted {:columnName "CATEGORY"
- :dimensions [{:columnName "CATEGORY"
- :value "ACME Corp"}]}
- :highlight_label "ACME Corp"}}]
- (testing "keeps its context for a superuser, who is exempt from the gate"
- (is (=? [{:highlighted {:columnName "CATEGORY"}
- :highlight_label "ACME Corp"}]
- (comment-contexts expl-id :crowberto))))
- (testing "is stripped of its context for a viewer whose data-access lens is incompatible —
- the comment itself remains readable, only the warehouse values it carries are withheld"
- (let [contexts (comment-contexts expl-id :rasta)]
- (is (= 1 (count contexts)) "the comment is still listed")
- (is (= [nil] contexts) "but carries no context"))))))))
+ (mt/user-http-request :lucky :post 200 "comment/"
+ {:target_type "exploration"
+ :target_id expl-id
+ :child_target_id (str page-id)
+ :content {:type "doc" :content []}
+ :context {:highlighted {:columnName "CATEGORY"
+ :dimensions [{:columnName "CATEGORY"
+ :value "ACME Corp"}]}
+ :highlight_label "ACME Corp"}})
+ (testing "keeps its context for a superuser, who is exempt from the gate"
+ (is (=? [{:highlighted {:columnName "CATEGORY"}
+ :highlight_label "ACME Corp"}]
+ (comment-contexts expl-id :crowberto))))
+ (testing "is stripped of its context for a viewer whose data-access lens is incompatible —
+ the comment itself remains readable, only the warehouse values it carries are withheld"
+ (let [contexts (comment-contexts expl-id :rasta)]
+ (is (= 1 (count contexts)) "the comment is still listed")
+ (is (= [nil] contexts) "but carries no context")))))))
(deftest content-gate-verdict-is-memoized-within-a-scope-test
(testing "every Card in a Summary document shares one document, and therefore one verdict. Without
diff --git a/test/metabase/explorations/disabled_test.clj b/test/metabase/explorations/disabled_test.clj
deleted file mode 100644
index a4500d905ac..00000000000
--- a/test/metabase/explorations/disabled_test.clj
+++ /dev/null
@@ -1,140 +0,0 @@
-(ns metabase.explorations.disabled-test
- "Every test that pins the disabled state of explorations, so the definition of \"disabled\" lives in one place: the
- API routes are unmounted, the Metabot profile is unregistered, and the listing surfaces that could hand a client
- residue exploration rows are closed. Rows can still exist: an instance upgraded to a version with explorations, used
- to create some, then downgraded keeps its exploration tables, since their migrations belong to this version."
- (:require
- [clojure.test :refer :all]
- [metabase.llm.settings :as llm.settings]
- [metabase.llm.test-util :as llm.tu]
- [metabase.metabot.scope :as scope]
- [metabase.metabot.settings :as metabot.settings]
- [metabase.search.appdb.index :as search.index]
- [metabase.search.config :as search.config]
- [metabase.search.core :as search]
- [metabase.search.test-util :as search.tu]
- [metabase.test :as mt]
- [metabase.test.fixtures :as fixtures]
- [toucan2.core :as t2]))
-
-(set! *warn-on-reflection* true)
-
-(use-fixtures :once (fixtures/initialize :db :web-server :test-users))
-
-(deftest exploration-routes-not-mounted-test
- (testing "The application does not serve /api/exploration"
- (mt/user-http-request :crowberto :get 404 "exploration/dimensions")))
-
-(deftest metabot-explorations-profile-unregistered-test
- (testing "Asking the agent for the explorations profile is rejected before a turn starts"
- (mt/with-temporary-setting-values [llm.settings/llm-providers llm.tu/default-connections
- metabot.settings/llm-metabot-provider "openrouter/anthropic/claude-haiku-4-5"]
- (binding [scope/*current-user-metabot-permissions* scope/all-yes-permissions]
- (mt/with-model-cleanup [:model/MetabotMessage [:model/MetabotConversation :created_at]]
- (let [conversation-id (str (random-uuid))]
- (is (=? {:message #"Unknown profile"}
- (mt/user-http-request :rasta :post 400 "metabot/agent-streaming"
- {:message "hello"
- :context {}
- :conversation_id conversation-id
- :state {}
- :profile_id "explorations"})))
- (is (empty? (t2/select :model/MetabotMessage :conversation_id conversation-id))
- "no turn was persisted")))))))
-
-(deftest collection-items-omit-explorations-test
- (testing "GET /api/collection/:id/items"
- (mt/with-temp [:model/Collection coll {}
- :model/Card card {:collection_id (:id coll)}
- :model/Exploration expl {:name "Residue exploration"
- :creator_id (mt/user->id :crowberto)
- :collection_id (:id coll)}]
- (let [url (str "collection/" (:id coll) "/items")]
- (testing "omits a residue exploration"
- (is (= [["card" (:id card)]]
- (map (juxt :model :id) (:data (mt/user-http-request :crowberto :get 200 url))))))
- (testing "does not report exploration as an available model"
- (is (= ["card"]
- (:available_models (mt/user-http-request :crowberto :get 200 url :include-available-models true)))))
- (testing "rejects a models parameter naming exploration"
- (is (=? {:errors {:models some?}}
- (mt/user-http-request :crowberto :get 400 url :models "exploration")))
- (is (=? {:errors {:models some?}}
- (mt/user-http-request :crowberto :get 400 url :models "card" :models "exploration"))))
- (testing "the exploration id is not reachable through the residue row"
- (is (not-any? #(= (:id expl) (:id %))
- (:data (mt/user-http-request :crowberto :get 200 url)))))))))
-
-(deftest bookmarks-omit-explorations-test
- (testing "GET /api/bookmark"
- (mt/with-temp [:model/Collection coll {}
- :model/Card card {:collection_id (:id coll)}
- :model/Exploration expl {:name "Residue exploration"
- :creator_id (mt/user->id :rasta)
- :collection_id (:id coll)}
- :model/CardBookmark _ {:user_id (mt/user->id :rasta) :card_id (:id card)}
- :model/ExplorationBookmark _ {:user_id (mt/user->id :rasta) :exploration_id (:id expl)}]
- (let [bookmarks (set (map (juxt :type :item_id) (mt/user-http-request :rasta :get 200 "bookmark")))]
- (testing "omits a residue exploration bookmark"
- (is (contains? bookmarks ["card" (:id card)]))
- (is (not-any? #(= "exploration" (first %)) bookmarks))))
- (testing "rejects creating or deleting an exploration bookmark"
- ;; the model enum is part of the route match, so an unknown model is a 404 like any other unknown model
- (is (= "API endpoint does not exist."
- (mt/user-http-request :rasta :post 404 (str "bookmark/exploration/" (:id expl)))))
- (is (= "API endpoint does not exist."
- (mt/user-http-request :rasta :delete 404 (str "bookmark/exploration/" (:id expl)))))
- (is (t2/exists? :model/ExplorationBookmark :exploration_id (:id expl) :user_id (mt/user->id :rasta))
- "the rejected delete left the residue row alone"))
- (testing "rejects an exploration in the bookmark ordering"
- (is (=? {:errors {:orderings some?}}
- (mt/user-http-request :rasta :put 400 "bookmark/ordering"
- {:orderings [{:type "exploration" :item_id (:id expl)}]})))))))
-
-(deftest search-omits-explorations-test
- (testing "GET /api/search"
- ;; the index table is only available on app DBs that support it; the in-place engine runs everywhere
- (search.tu/with-temp-index-table-if-supported
- (let [term (mt/random-name)
- search (fn [& args]
- (apply mt/user-http-request :crowberto :get 200 "search" :q term args))
- engines (cond-> ["in-place"]
- (search/supports-index?) (conj "appdb"))]
- (mt/with-temp [:model/Exploration expl {:name (str "Residue " term)
- :creator_id (mt/user->id :crowberto)}]
- (when (search/supports-index?)
- (testing "the residue row is still ingested into the index"
- (is (t2/exists? (search.index/active-table) :model "exploration" :model_id (str (:id expl))))))
- (doseq [engine engines]
- (testing (str "the " engine " engine")
- (testing "omits the row"
- (is (empty? (:data (search :search_engine engine)))))
- (testing "does not list exploration as an available model"
- (is (not (contains? (set (:available_models (search :search_engine engine
- :calculate_available_models true)))
- "exploration"))))))
- (testing "a models filter naming exploration is rejected"
- (is (=? {:errors {:models some?}}
- (mt/user-http-request :crowberto :get 400 "search" :q term :models "exploration")))))))))
-
-(deftest search-config-excludes-explorations-test
- (testing "exploration is not a searchable model"
- (is (not (contains? search.config/all-models "exploration")))
- (is (contains? search.config/excluded-models "exploration")))
- (testing "the models search order still covers exactly the searchable models"
- (is (= search.config/all-models (set search.config/models-search-order)))))
-
-(deftest comments-reject-exploration-targets-test
- (mt/with-temp [:model/Exploration expl {:name "Residue exploration"
- :creator_id (mt/user->id :crowberto)}]
- (testing "GET /api/comment/ rejects an exploration target"
- (is (=? {:errors {:target_type some?}}
- (mt/user-http-request :crowberto :get 400 "comment/"
- :target_type "exploration" :target_id (:id expl)))))
- (testing "POST /api/comment/ rejects an exploration target"
- (is (=? {:errors {:target_type some?}}
- (mt/user-http-request :crowberto :post 400 "comment/"
- {:target_type "exploration"
- :target_id (:id expl)
- :content {:type "doc" :content [{:type "paragraph"
- :content [{:type "text" :text "hi"}]}]}}))))))
diff --git a/test/metabase/explorations/models/exploration_test.clj b/test/metabase/explorations/models/exploration_test.clj
index 09f59a15726..287b54b77b7 100644
--- a/test/metabase/explorations/models/exploration_test.clj
+++ b/test/metabase/explorations/models/exploration_test.clj
@@ -7,7 +7,11 @@
[metabase.models.interface :as mi]
[metabase.permissions.core :as perms]
[metabase.permissions.models.permissions-group :as perms-group]
+ [metabase.search.config :as search.config]
+ [metabase.search.core :as search]
+ [metabase.search.ingestion :as search.ingestion]
[metabase.search.spec :as search.spec]
+ [metabase.search.test-util :as search.tu]
[metabase.test :as mt]
[metabase.test.fixtures :as fixtures]
[toucan2.core :as t2]))
@@ -160,11 +164,32 @@
(is (= "d1" (:dimension_id reread)))
(is (= 1 (-> reread :dataset_query :database)))))))
-(deftest exploration-search-spec-is-registered-test
- ;; Explorations are still ingested into the search index; that the closed search surface omits them is pinned in
- ;; `metabase.explorations.disabled-test`.
+(deftest exploration-is-searchable-test
+ ;; The wiring assertions run unconditionally so this test can never silently pass
+ ;; with zero assertions; only the index round-trip below is gated on engine support.
(testing "the exploration search-model is wired up"
- (is (= :model/Exploration (:model (search.spec/spec "exploration"))))))
+ (is (= :model/Exploration (:model (search.spec/spec "exploration"))))
+ (is (contains? search.config/all-models "exploration")))
+ (testing "an exploration is indexed and returned from the default search"
+ (when (search/supports-index?)
+ (search.tu/with-temp-index-table
+ (mt/with-temp [:model/Collection coll {}
+ :model/Exploration e {:name "searchable-research" :collection_id (:id coll)}]
+ (letfn [(research-hits [user]
+ (->> (search.tu/search-results "searchable-research"
+ {:search-engine "appdb"
+ :current-user-id (mt/user->id user)})
+ (filter (comp #{"searchable-research"} :name))
+ (mapv (juxt :model :id))))]
+ (search.ingestion/update!
+ (#'search.ingestion/query->documents
+ (#'search.ingestion/spec-index-reducible "exploration" [:= :this.id (:id e)]))
+ [])
+ (testing "a user who can read the collection finds it"
+ (is (= [["exploration" (:id e)]] (research-hits :crowberto))))
+ (testing "a user without collection perms does not"
+ (mt/with-non-admin-groups-no-collection-perms coll
+ (is (= [] (research-hits :rasta)))))))))))
(deftest hydrate-threads-on-exploration-test
(mt/with-temp [:model/User u {}
diff --git a/test/metabase/explorations/test_util.clj b/test/metabase/explorations/test_util.clj
deleted file mode 100644
index d88cc83f2ed..00000000000
--- a/test/metabase/explorations/test_util.clj
+++ /dev/null
@@ -1,28 +0,0 @@
-(ns metabase.explorations.test-util
- "Test helpers for the explorations module."
- (:require
- [metabase.api.routes.common :as routes.common]
- [metabase.api.util.handlers :as handlers]
- [metabase.explorations.api :as explorations.api]
- [metabase.server.test-handler :as server.test-handler]))
-
-(set! *warn-on-reflection* true)
-
-(def ^:private api-routes-with-explorations
- "The application's API route tree with `/api/exploration` mounted in front of it, wrapped the same way
- [[metabase.api-routes.routes/route-map]] mounted it before explorations were disabled."
- (delay
- (handlers/routes
- (handlers/route-map-handler {"/exploration" (routes.common/+auth explorations.api/routes)})
- (server.test-handler/app-api-routes))))
-
-(defn do-with-exploration-routes
- "Run `thunk` with `/api/exploration` served by the test HTTP client. The application does not mount the explorations
- API while the feature is disabled, so tests that exercise its endpoints over HTTP need this."
- [thunk]
- (server.test-handler/do-with-api-routes @api-routes-with-explorations thunk))
-
-(defn exploration-routes-fixture
- "`clojure.test` fixture form of [[do-with-exploration-routes]]."
- [f]
- (do-with-exploration-routes f))
diff --git a/test/metabase/metabot/agent/profiles_test.clj b/test/metabase/metabot/agent/profiles_test.clj
index a5db2e5b287..d2872a0f344 100644
--- a/test/metabase/metabot/agent/profiles_test.clj
+++ b/test/metabase/metabot/agent/profiles_test.clj
@@ -5,7 +5,6 @@
[metabase.entity-retrieval.core :as entity-retrieval]
[metabase.metabot.agent.profiles :as profiles]
[metabase.metabot.scope :as scope]
- [metabase.metabot.test-util :as mut]
[metabase.metabot.tools :as tools]
[metabase.test :as mt]))
@@ -70,6 +69,10 @@
(is (contains? (tool-names profile) "create_dashboard_subscription"))))
(testing "returns nil for unknown profile"
(is (nil? (profiles/get-profile :unknown-profile))))
+ (testing "profile-registered? distinguishes registered profiles from unknown ones"
+ (is (true? (profiles/profile-registered? :embedding_next)))
+ (is (true? (profiles/profile-registered? :explorations)))
+ (is (false? (profiles/profile-registered? :unknown-profile))))
(testing "all profiles have required keys"
(doseq [profile-id [:embedding_next :internal :sql :nlq :slackbot]]
(let [profile (profiles/get-profile profile-id)]
@@ -204,18 +207,11 @@
(assoc base :skills? false :always-on-skills [:read-resource])))))))
(deftest explorations-profile-disables-skills-test
- (mut/do-with-registered-profile!
- profiles/explorations-profile
- (fn []
- (binding [scope/*current-user-scope* api-scope/unrestricted]
- (testing "explorations opts out of skills so read_resource does not inject load_skill"
- (let [profile (profiles/get-profile :explorations)
- tools (profiles/profile->tools profile [])]
- (is (false? (:skills? profile)))
- (is (contains? tools "read_resource")
- "precondition: read_resource is active (would otherwise match a skill)")
- (is (not (contains? tools "load_skill")))))))))
-
-(deftest explorations-profile-not-registered-test
- (testing "The :explorations profile is not registered while explorations are disabled"
- (is (nil? (profiles/get-profile :explorations)))))
+ (binding [scope/*current-user-scope* api-scope/unrestricted]
+ (testing "explorations opts out of skills so read_resource does not inject load_skill"
+ (let [profile (profiles/get-profile :explorations)
+ tools (profiles/profile->tools profile [])]
+ (is (false? (:skills? profile)))
+ (is (contains? tools "read_resource")
+ "precondition: read_resource is active (would otherwise match a skill)")
+ (is (not (contains? tools "load_skill")))))))
diff --git a/test/metabase/metabot/api_test.clj b/test/metabase/metabot/api_test.clj
index 69267b68553..f94fc78f186 100644
--- a/test/metabase/metabot/api_test.clj
+++ b/test/metabase/metabot/api_test.clj
@@ -528,6 +528,30 @@
(thunk)
(is (empty? @queue) "unconsumed mock LLM responses"))))))))
+(deftest agent-streaming-rejects-unknown-profile-test
+ (testing "agent-streaming rejects an unregistered profile before starting a turn"
+ (mt/with-temporary-setting-values [llm.settings/llm-providers llm.tu/default-connections
+ metabot.settings/llm-metabot-provider test-provider]
+ (binding [scope/*current-user-metabot-permissions* scope/all-yes-permissions]
+ (let [title-calls (atom 0)
+ llm-calls (atom 0)
+ conversation-id (str (random-uuid))]
+ (mt/with-dynamic-fn-redefs [openrouter/openrouter (fn [_] (swap! llm-calls inc) (mut/mock-llm-response []))
+ conversation-title/ensure-title! (fn [& _] (swap! title-calls inc) {:status :ready :title "x"})]
+ (mt/with-model-cleanup [:model/MetabotMessage [:model/MetabotConversation :created_at]]
+ (is (=? {:message #"Unknown profile"}
+ (mt/user-http-request :rasta :post 400 "metabot/agent-streaming"
+ {:message "hello"
+ :context {}
+ :conversation_id conversation-id
+ :state {}
+ :profile_id "no_such_profile"})))
+ (testing "nothing was persisted and no LLM call was made"
+ (is (nil? (t2/select-one :model/MetabotConversation :id conversation-id)))
+ (is (empty? (t2/select :model/MetabotMessage :conversation_id conversation-id)))
+ (is (zero? @title-calls))
+ (is (zero? @llm-calls))))))))))
+
(deftest agent-streaming-rejects-stale-parent-message-id-test
(testing "agent-streaming accepts nil/matching parent_message_id, rejects one that no longer matches the leaf"
(with-mock-streaming-provider!
diff --git a/test/metabase/metabot/test_util.clj b/test/metabase/metabot/test_util.clj
index 90079983288..54e31d590a3 100644
--- a/test/metabase/metabot/test_util.clj
+++ b/test/metabase/metabot/test_util.clj
@@ -2,8 +2,6 @@
(:require
[clojure.java.io :as io]
[clojure.string :as str]
- [mb.hawk.parallel]
- [metabase.metabot.agent.profiles :as profiles]
[metabase.metabot.self.core :as self.core]
[metabase.metabot.tools :as metabot.tools]
[metabase.util.json :as json]
@@ -190,19 +188,3 @@
:display-name "snip"
:snippet-id Integer/MAX_VALUE}}}
{:lib/type :mbql.stage/mbql}]})
-
-;;; ──────────────────────────────────────────────────────────────────
-;;; Profiles
-;;; ──────────────────────────────────────────────────────────────────
-
-(defn do-with-registered-profile!
- "Run `thunk` with `profile` registered in the agent profile registry, restoring the registry afterwards. For
- profiles the application defines but does not register, such as [[profiles/explorations-profile]]."
- [profile thunk]
- (mb.hawk.parallel/assert-test-is-not-parallel "do-with-registered-profile!")
- (let [registry @#'profiles/*profiles]
- (try
- (#'profiles/register-profile! profile)
- (thunk)
- (finally
- (swap! registry dissoc (:name profile))))))
diff --git a/test/metabase/metabot/tools/explorations_test.clj b/test/metabase/metabot/tools/explorations_test.clj
index d20a6aabc09..745b1b957f6 100644
--- a/test/metabase/metabot/tools/explorations_test.clj
+++ b/test/metabase/metabot/tools/explorations_test.clj
@@ -8,7 +8,6 @@
[metabase.metabot.agent.streaming :as streaming]
[metabase.metabot.scope :as scope]
[metabase.metabot.self.core :as metabot.self]
- [metabase.metabot.test-util :as mut]
[metabase.metabot.tools.explorations :as tools.explorations]
[metabase.test :as mt]
[metabase.util.json :as json]))
@@ -228,21 +227,18 @@
"Draft")))))
(deftest explorations-profile-renders-research-plan-in-system-prompt-test
- (mut/do-with-registered-profile!
- profiles/explorations-profile
- (fn []
- (testing "the registered :explorations profile wires research-plan-system-context, so a draft plan
+ (testing "the registered :explorations profile wires research-plan-system-context, so a draft plan
reaches the LLM's system prompt (the feature the generic agent no longer knows about)"
- (let [profile (profiles/get-profile :explorations)
- plan {:name "Why was revenue down?"
- :groups [{:block_id "metric:42"
- :metric {:id 42 :name "Revenue"}
- :dimensions [{:id "d1" :name "Region"}]}]}
- content (:content (messages/build-system-message {:research_plan plan} profile {}))]
- (is (str/includes? content "Current research plan"))
- (is (str/includes? content "Why was revenue down?"))
- (is (str/includes? content "[metric:42] Revenue, broken out by: Region (d1)")))
- (testing "and omits the plan section entirely when there is no plan"
- (let [content (:content (messages/build-system-message
- {} (profiles/get-profile :explorations) {}))]
- (is (not (str/includes? content "Current research plan")))))))))
+ (let [profile (profiles/get-profile :explorations)
+ plan {:name "Why was revenue down?"
+ :groups [{:block_id "metric:42"
+ :metric {:id 42 :name "Revenue"}
+ :dimensions [{:id "d1" :name "Region"}]}]}
+ content (:content (messages/build-system-message {:research_plan plan} profile {}))]
+ (is (str/includes? content "Current research plan"))
+ (is (str/includes? content "Why was revenue down?"))
+ (is (str/includes? content "[metric:42] Revenue, broken out by: Region (d1)")))
+ (testing "and omits the plan section entirely when there is no plan"
+ (let [content (:content (messages/build-system-message
+ {} (profiles/get-profile :explorations) {}))]
+ (is (not (str/includes? content "Current research plan")))))))
diff --git a/test/metabase/search/api_test.clj b/test/metabase/search/api_test.clj
index 270fcde4f1e..aaba427e0cc 100644
--- a/test/metabase/search/api_test.clj
+++ b/test/metabase/search/api_test.clj
@@ -2296,3 +2296,12 @@
:q table-name :models "table" :search_engine "appdb"))]
(is (seq rows))
(is (every? (comp nil? :is_published) rows)))))))))))
+
+(deftest exploration-description-searchable-in-place-test
+ (testing "explorations match on :description in the in-place engine (parity with the appdb spec)"
+ (let [description (mt/random-name)]
+ (mt/with-temp [:model/Exploration _ {:name "desc-probe-exploration"
+ :description description
+ :creator_id (mt/user->id :crowberto)}]
+ (is (=? [{:model "exploration" :name "desc-probe-exploration"}]
+ (search-request-data :crowberto :q description :search_engine "in-place")))))))
diff --git a/test/metabase/search/filter_test.clj b/test/metabase/search/filter_test.clj
index e10c67e07b7..5e803dd5bf6 100644
--- a/test/metabase/search/filter_test.clj
+++ b/test/metabase/search/filter_test.clj
@@ -67,7 +67,7 @@
(is (= (disj search.config/all-models "transform")
(search.filter/search-context->applicable-models (with-all-models-and-regular-user {:archived? false})))))
(testing "We only search for certain models in the trash"
- (is (= #{"dashboard" "dataset" "document" "segment" "measure" "collection" "action" "metric" "card"}
+ (is (= #{"dashboard" "dataset" "document" "exploration" "segment" "measure" "collection" "action" "metric" "card"}
(search.filter/search-context->applicable-models (with-all-models-and-regular-user {:archived? true})))))
(testing "Indexed entities and transforms (which are admin-only) are not visible for sandboxed users"
(is (= (disj search.config/all-models "indexed-entity" "transform")
@@ -143,6 +143,7 @@
"measure"
"transform"
"document"
+ "exploration"
"database"
"action"
"indexed-entity"
diff --git a/test/metabase/search/in_place/filter_test.clj b/test/metabase/search/in_place/filter_test.clj
index a94361f5543..3ab910fea92 100644
--- a/test/metabase/search/in_place/filter_test.clj
+++ b/test/metabase/search/in_place/filter_test.clj
@@ -43,7 +43,7 @@
(deftest ^:parallel ->applicable-models-test-2
(testing "optional filters will return intersection of support models and provided models\n"
(testing "created by"
- (is (= #{"dashboard" "dataset" "document" "action" "card" "metric" "measure"}
+ (is (= #{"dashboard" "dataset" "document" "exploration" "action" "card" "metric" "measure"}
(search.filter/search-context->applicable-models
(merge default-search-ctx
{:created-by #{1}}))))
@@ -53,7 +53,7 @@
{:models #{"dashboard" "dataset" "table"}
:created-by #{1}})))))
(testing "created at"
- (is (= #{"dashboard" "table" "dataset" "document" "collection" "database" "action" "card" "metric" "transform" "measure"}
+ (is (= #{"dashboard" "table" "dataset" "document" "exploration" "collection" "database" "action" "card" "metric" "transform" "measure"}
(search.filter/search-context->applicable-models
(merge default-search-ctx
{:created-at "past3days"}))))
diff --git a/test/metabase/server/test_handler.clj b/test/metabase/server/test_handler.clj
index 5c8584fb80a..d0c20af5f4c 100644
--- a/test/metabase/server/test_handler.clj
+++ b/test/metabase/server/test_handler.clj
@@ -5,50 +5,28 @@
[metabase.util.log :as log]
[metabase.util.malli :as mu]))
-(defn app-api-routes
- "The application's own API route tree, the handler mounted under `/api`."
+(mu/defn- make-test-handler :- ::api.macros/handler
[]
;; late-bound: a static require here would drag the whole API route tree into the server module
- #_{:clj-kondo/ignore [:metabase/modules]} (requiring-resolve 'metabase.api-routes.core/routes))
-
-(mu/defn make-test-handler :- ::api.macros/handler
- "Build the full Ring handler (server routes plus middleware) that serves `api-routes` under `/api`. Defaults to
- [[app-api-routes]]."
- ([]
- (make-test-handler (app-api-routes)))
-
- ([api-routes :- ::api.macros/handler]
- (let [server-routes (server/make-routes api-routes)
- handler (server/make-handler server-routes)]
- (fn [request respond raise]
- (letfn [(raise' [e]
- (log/errorf "ERROR HANDLING REQUEST! <async raise> %s" request)
- (log/error e)
- (raise e))]
- (try
- (handler request respond raise')
- (catch Throwable e
- (log/errorf "ERROR HANDLING REQUEST! <async thrown> %s" request)
- (log/error e)
- (throw e))))))))
+ (let [api-routes #_{:clj-kondo/ignore [:metabase/modules]} (requiring-resolve 'metabase.api-routes.core/routes)
+ server-routes (server/make-routes api-routes)
+ handler (server/make-handler server-routes)]
+ (fn [request respond raise]
+ (letfn [(raise' [e]
+ (log/errorf "ERROR HANDLING REQUEST! <async raise> %s" request)
+ (log/error e)
+ (raise e))]
+ (try
+ (handler request respond raise')
+ (catch Throwable e
+ (log/errorf "ERROR HANDLING REQUEST! <async thrown> %s" request)
+ (log/error e)
+ (throw e)))))))
(def ^:private -test-handler
(delay (make-test-handler)))
-(def ^:dynamic *test-handler*
- "When bound, [[test-handler]] returns this handler instead of the default one built from [[app-api-routes]]. Bind
- it via [[do-with-api-routes]] to test API routes that the application does not mount."
- nil)
-
(defn test-handler
"Build the Ring handler used in tests and by `dev`."
[]
- (or *test-handler* @-test-handler))
-
-(defn do-with-api-routes
- "Run `thunk` with the test HTTP client serving `api-routes` under `/api` instead of the application's own route
- tree. `api-routes` is a Ring handler such as one built with [[metabase.api.util.handlers/routes]]; compose it with
- [[app-api-routes]] to fall through to the application's routes."
- [api-routes thunk]
- (binding [*test-handler* (make-test-handler api-routes)]
- (thunk)))
+ @-test-handler)