Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/walking-skeleton.test.tsx
T

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();
});
});