Skip to content

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

e2e2unit: migrate onboarding glossary e2e specs to jest (#85203)

Uladzimir Havenchyke151f8233087
diff --git a/e2e/test/scenarios/onboarding/reference/glossary.cy.spec.ts b/e2e/test/scenarios/onboarding/reference/glossary.cy.spec.ts
index 2f99a612665..e67dd542541 100644
--- a/e2e/test/scenarios/onboarding/reference/glossary.cy.spec.ts
+++ b/e2e/test/scenarios/onboarding/reference/glossary.cy.spec.ts
@@ -95,15 +95,6 @@ describe("data reference > glossary", () => {
cy.findByText("Beta").should("be.visible");
});
});
-
- it("creates, updates, and deletes definitions with trimmed API values", () => {
- visitGlossary();
- executeCreateGlossaryTermFlow();
-
- executeUpdateGlossaryTermFlow();
-
- executeDeleteGlossaryTermFlow();
- });
});
describe("data studio > glossary", () => {
diff --git a/frontend/src/metabase/reference/glossary/GlossaryContainer.unit.spec.tsx b/frontend/src/metabase/reference/glossary/GlossaryContainer.unit.spec.tsx
index 70d976d859b..248940ff443 100644
--- a/frontend/src/metabase/reference/glossary/GlossaryContainer.unit.spec.tsx
+++ b/frontend/src/metabase/reference/glossary/GlossaryContainer.unit.spec.tsx
@@ -1,8 +1,16 @@
+import userEvent from "@testing-library/user-event";
import fetchMock from "fetch-mock";
+import {
+ setupCreateGlossaryEndpoint,
+ setupDeleteGlossaryEndpoint,
+ setupListGlossaryEndpoint,
+ setupUpdateGlossaryEndpoint,
+} from "__support__/server-mocks";
import { createMockState } from "__support__/state";
-import { renderWithProviders, screen } from "__support__/ui";
+import { renderWithProviders, screen, waitFor, within } from "__support__/ui";
import type { GlossaryItem } from "metabase/api";
+import { defer } from "metabase/utils/promise";
import { createMockUser } from "metabase-types/api/mocks";
import { GlossaryContainer } from "./GlossaryContainer";
@@ -11,10 +19,18 @@ const GLOSSARY: GlossaryItem[] = [
{ id: 1, term: "ARR", definition: "Annual recurring revenue" },
];
+type SetupOpts = {
+ canWrite: boolean;
+ getGlossary?: () => GlossaryItem[];
+};
+
// Writability comes from the API: `can_write` mirrors api/entitled-data-analyst?, which gates the
// glossary write endpoints, so the container never has to reason about roles or token features itself.
-const setup = ({ canWrite }: { canWrite: boolean }) => {
- fetchMock.get("path:/api/glossary", { data: GLOSSARY, can_write: canWrite });
+const setup = ({ canWrite, getGlossary = () => GLOSSARY }: SetupOpts) => {
+ setupListGlossaryEndpoint(() => ({
+ data: getGlossary(),
+ can_write: canWrite,
+ }));
renderWithProviders(<GlossaryContainer />, {
storeInitialState: createMockState({
@@ -26,6 +42,115 @@ const setup = ({ canWrite }: { canWrite: boolean }) => {
const getNewTermButton = () => screen.queryByRole("button", { name: /term/i });
+const getTable = () => screen.getByRole("table");
+
+const getRequestBody = (url: string, method: "POST" | "PUT"): unknown => {
+ const body = fetchMock.callHistory.lastCall(url, { method })?.options.body;
+ if (body == null) {
+ return undefined;
+ }
+ const parsedBody: unknown = JSON.parse(body.toString());
+ return parsedBody;
+};
+
+type GlossaryServer = { glossary: GlossaryItem[] };
+
+const BOAT: GlossaryItem = {
+ id: 7,
+ term: "Boat",
+ definition: "A small vessel for traveling on water.",
+};
+
+const KITTEN: GlossaryItem = {
+ id: 7,
+ term: "Kitten",
+ definition: "Young cat",
+};
+
+async function assertCreateGlossaryTermFlow(server: GlossaryServer) {
+ const createResponse = defer<GlossaryItem>();
+ setupCreateGlossaryEndpoint(() => createResponse.promise);
+
+ await userEvent.click(
+ await screen.findByRole("button", { name: /new term/i }),
+ );
+ await userEvent.type(screen.getByPlaceholderText(/boat/i), " Boat ");
+ await userEvent.type(
+ screen.getByPlaceholderText(/a small vessel.*/i),
+ " A small vessel for traveling on water. ",
+ );
+ await userEvent.click(screen.getByLabelText("Save"));
+
+ await waitFor(() =>
+ expect(
+ fetchMock.callHistory.called("path:/api/glossary", { method: "POST" }),
+ ).toBe(true),
+ );
+ // The row shown while the request is pending is replaced by the server's row.
+ const pendingTerm = within(getTable()).getByText("Boat");
+ server.glossary = [BOAT];
+ createResponse.resolve(BOAT);
+ await waitFor(() => expect(pendingTerm).not.toBeInTheDocument());
+
+ expect(getRequestBody("path:/api/glossary", "POST")).toEqual({
+ term: "Boat",
+ definition: "A small vessel for traveling on water.",
+ });
+ expect(within(getTable()).getByText("Boat")).toBeInTheDocument();
+ expect(
+ within(getTable()).getByText("A small vessel for traveling on water."),
+ ).toBeInTheDocument();
+}
+
+async function assertUpdateGlossaryTermFlow(server: GlossaryServer) {
+ setupUpdateGlossaryEndpoint(KITTEN);
+
+ await userEvent.click(within(getTable()).getByText("Boat"));
+ await userEvent.clear(screen.getByPlaceholderText(/boat/i));
+ await userEvent.type(screen.getByPlaceholderText(/boat/i), "Kitten");
+ await userEvent.clear(screen.getByPlaceholderText(/a small vessel.*/i));
+ await userEvent.type(
+ screen.getByPlaceholderText(/a small vessel.*/i),
+ "Young cat",
+ );
+ server.glossary = [KITTEN];
+ await userEvent.click(screen.getByRole("button", { name: /save/i }));
+
+ await waitFor(() =>
+ expect(getRequestBody("path:/api/glossary/7", "PUT")).toEqual({
+ term: "Kitten",
+ definition: "Young cat",
+ }),
+ );
+ expect(await within(getTable()).findByText("Kitten")).toBeInTheDocument();
+ expect(within(getTable()).getByText("Young cat")).toBeInTheDocument();
+}
+
+async function assertDeleteGlossaryTermFlow(server: GlossaryServer) {
+ setupDeleteGlossaryEndpoint(KITTEN.id);
+
+ server.glossary = [];
+ await userEvent.click(
+ within(getTable()).getByRole("button", { name: /delete/i }),
+ );
+ await userEvent.click(
+ within(await screen.findByRole("dialog")).getByRole("button", {
+ name: /delete/i,
+ }),
+ );
+
+ await waitFor(() =>
+ expect(
+ fetchMock.callHistory.called("path:/api/glossary/7", {
+ method: "DELETE",
+ }),
+ ).toBe(true),
+ );
+ await waitFor(() =>
+ expect(within(getTable()).queryByText("Kitten")).not.toBeInTheDocument(),
+ );
+}
+
describe("GlossaryContainer", () => {
it("lets the user manage the glossary when the API reports it as writable", async () => {
setup({ canWrite: true });
@@ -40,4 +165,15 @@ describe("GlossaryContainer", () => {
expect(await screen.findByText("ARR")).toBeInTheDocument();
expect(getNewTermButton()).not.toBeInTheDocument();
});
+
+ it("creates, updates, and deletes definitions with trimmed API values", async () => {
+ const server: GlossaryServer = { glossary: [] };
+ setup({ canWrite: true, getGlossary: () => server.glossary });
+
+ await assertCreateGlossaryTermFlow(server);
+
+ await assertUpdateGlossaryTermFlow(server);
+
+ await assertDeleteGlossaryTermFlow(server);
+ });
});
diff --git a/frontend/test/__support__/server-mocks/glossary.ts b/frontend/test/__support__/server-mocks/glossary.ts
new file mode 100644
index 00000000000..6679885b1ed
--- /dev/null
+++ b/frontend/test/__support__/server-mocks/glossary.ts
@@ -0,0 +1,25 @@
+import fetchMock from "fetch-mock";
+
+import type { GlossaryItem, ListGlossaryResponse } from "metabase/api";
+
+import type { MockResponse } from "./types";
+
+export function setupListGlossaryEndpoint(
+ response: MockResponse<ListGlossaryResponse>,
+) {
+ fetchMock.get("path:/api/glossary", response);
+}
+
+export function setupCreateGlossaryEndpoint(
+ response: MockResponse<GlossaryItem>,
+) {
+ fetchMock.post("path:/api/glossary", response);
+}
+
+export function setupUpdateGlossaryEndpoint(item: GlossaryItem) {
+ fetchMock.put(`path:/api/glossary/${item.id}`, item);
+}
+
+export function setupDeleteGlossaryEndpoint(id: GlossaryItem["id"]) {
+ fetchMock.delete(`path:/api/glossary/${id}`, 204);
+}
diff --git a/frontend/test/__support__/server-mocks/index.ts b/frontend/test/__support__/server-mocks/index.ts
index 66e11946ca3..d308eea4a91 100644
--- a/frontend/test/__support__/server-mocks/index.ts
+++ b/frontend/test/__support__/server-mocks/index.ts
@@ -27,6 +27,7 @@ export * from "./embedding-sdk";
export * from "./field";
export * from "./gdrive";
export * from "./geojson";
+export * from "./glossary";
export * from "./google";
export * from "./group";
export * from "./impersonation";