126 lines
4.8 KiB
TypeScript
126 lines
4.8 KiB
TypeScript
import "@testing-library/jest-dom";
|
|
import { render, screen } from "@testing-library/react";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { MemoryRouter } from "react-router";
|
|
import type { LoaderFunctionArgs } from "react-router";
|
|
import type { WalkingSkeletonVM } from "@toolctrl/view-models";
|
|
import WalkingSkeletonRoute, { loader } from "./walking-skeleton";
|
|
import { requireAuth } from "~/utils/loaders.middleware";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
|
|
import { getUserInfo } from "~/utils/session.server";
|
|
import { tenantHasModule } from "~/utils/connector/tenantConnector.server";
|
|
|
|
let routeLoaderData: { title: string; vm: WalkingSkeletonVM };
|
|
|
|
vi.mock("react-router", async () => {
|
|
const actual = await vi.importActual<typeof import("react-router")>("react-router");
|
|
return { ...actual, useLoaderData: () => routeLoaderData };
|
|
});
|
|
|
|
vi.mock("react-i18next", () => ({
|
|
useTranslation: () => ({ t: (key: string) => key }),
|
|
}));
|
|
|
|
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: vi.fn() }));
|
|
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
|
|
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() }));
|
|
vi.mock("~/utils/session.server", () => ({ getUserInfo: vi.fn() }));
|
|
vi.mock("~/utils/connector/tenantConnector.server", () => ({ tenantHasModule: vi.fn() }));
|
|
vi.mock("~/components/ui/errors/ServerError", () => ({ default: () => <div /> }));
|
|
|
|
const requireAuthMock = vi.mocked(requireAuth);
|
|
const getTranslationsMock = vi.mocked(getTranslations);
|
|
const getTenantIdFromUrlMock = vi.mocked(getTenantIdFromUrl);
|
|
const getUserInfoMock = vi.mocked(getUserInfo);
|
|
const tenantHasModuleMock = vi.mocked(tenantHasModule);
|
|
|
|
function loaderArgs(): LoaderFunctionArgs {
|
|
return {
|
|
request: new Request("http://localhost/app/acme/walking-skeleton"),
|
|
params: { tenant: "acme" },
|
|
context: {},
|
|
unstable_pattern: "app.$tenant/walking-skeleton",
|
|
} as unknown as LoaderFunctionArgs;
|
|
}
|
|
|
|
describe("walking-skeleton route loader", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
requireAuthMock.mockResolvedValue(undefined as never);
|
|
getTranslationsMock.mockResolvedValue({ t: (key: string) => key } as never);
|
|
getTenantIdFromUrlMock.mockResolvedValue("tenant_1" as never);
|
|
getUserInfoMock.mockResolvedValue({ userId: "user_1" } as never);
|
|
});
|
|
|
|
it("gates via tenantHasModule and builds an active VM when the module is allowed", async () => {
|
|
tenantHasModuleMock.mockResolvedValue(true);
|
|
|
|
const response = (await loader(loaderArgs())) as Response;
|
|
const data = await response.json();
|
|
|
|
expect(tenantHasModuleMock).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", moduleKey: "walking-skeleton" });
|
|
expect(data.vm.status).toBe("ready");
|
|
expect(data.vm.data.connectorState).toBe("active");
|
|
});
|
|
|
|
it("builds a locked VM when the connector denies the module", async () => {
|
|
tenantHasModuleMock.mockResolvedValue(false);
|
|
|
|
const response = (await loader(loaderArgs())) as Response;
|
|
const data = await response.json();
|
|
|
|
expect(data.vm.data.connectorState).toBe("locked");
|
|
expect(data.vm.data.ctaKey).toBe("walkingSkeleton.locked.cta");
|
|
});
|
|
});
|
|
|
|
describe("walking-skeleton route component", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it("renders the active state with the connector-state marker", () => {
|
|
routeLoaderData = {
|
|
title: "Walking Skeleton",
|
|
vm: { status: "ready", data: { tenantId: "t1", moduleKey: "walking-skeleton", connectorState: "active", headlineKey: "walkingSkeleton.active.headline", bodyKey: "walkingSkeleton.active.body" } },
|
|
};
|
|
|
|
render(
|
|
<MemoryRouter>
|
|
<WalkingSkeletonRoute />
|
|
</MemoryRouter>
|
|
);
|
|
|
|
const page = screen.getByText("walkingSkeleton.active.headline").closest("main");
|
|
expect(page).toHaveAttribute("data-connector-state", "active");
|
|
});
|
|
|
|
it("renders the upsell CTA in the locked state", () => {
|
|
routeLoaderData = {
|
|
title: "Walking Skeleton",
|
|
vm: { status: "ready", data: { tenantId: "t1", moduleKey: "walking-skeleton", connectorState: "locked", headlineKey: "walkingSkeleton.locked.headline", bodyKey: "walkingSkeleton.locked.body", ctaKey: "walkingSkeleton.locked.cta" } },
|
|
};
|
|
|
|
render(
|
|
<MemoryRouter>
|
|
<WalkingSkeletonRoute />
|
|
</MemoryRouter>
|
|
);
|
|
|
|
expect(screen.getByText("walkingSkeleton.locked.cta")).toBeInTheDocument();
|
|
});
|
|
|
|
it("renders the empty state when the VM is not ready", () => {
|
|
routeLoaderData = { title: "Walking Skeleton", vm: { status: "empty" } };
|
|
|
|
render(
|
|
<MemoryRouter>
|
|
<WalkingSkeletonRoute />
|
|
</MemoryRouter>
|
|
);
|
|
|
|
expect(screen.getByText("walkingSkeleton.empty.headline")).toBeInTheDocument();
|
|
});
|
|
});
|