Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/modules/onboarding/services/OnboardingService.single-user-tenant-flow.test.ts
T

254 lines
11 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
import type { OnboardingFilter, OnboardingSession } from "@toolctrl/db/prisma-browser";
import OnboardingService from "./OnboardingService";
import { createOnboardingSession, getOnboardings } from "../db/onboarding.db.server";
import { getOnboardingSession, getOnboardingSessionsByUser } from "../db/onboardingSessions.db.server";
import OnboardingFiltersService from "./OnboardingFiltersService";
import OnboardingSessionService from "./OnboardingSessionService";
import { evaluateOnboardingStepGates, getVisibleOnboardingSteps } from "./step-registry/gating.server";
vi.mock("~/utils/db/appConfiguration.db.server", () => ({
getAppConfiguration: vi.fn(async () => ({ onboarding: { enabled: true } })),
}));
vi.mock("~/utils/db/entities/entities.db.server", () => ({
getAllEntities: vi.fn(),
}));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({
getAllRoles: vi.fn(),
}));
vi.mock("~/utils/db/subscriptionProducts.db.server", () => ({
getAllSubscriptionProducts: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
adminGetAllTenants: vi.fn(),
getAllTenantUsers: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
adminGetAllUsers: vi.fn(),
}));
vi.mock("../db/onboarding.db.server", () => ({
createOnboardingSession: vi.fn(),
getOnboarding: vi.fn(),
getOnboardings: vi.fn(),
updateOnboarding: vi.fn(),
}));
vi.mock("../db/onboardingSessions.db.server", () => ({
getOnboardingSession: vi.fn(),
getOnboardingSessionsByUser: vi.fn(),
}));
vi.mock("./OnboardingFiltersService", () => ({
default: {
matches: vi.fn(),
},
}));
vi.mock("./OnboardingSessionService", () => ({
default: {
started: vi.fn(),
},
}));
vi.mock("~/utils/services/.server/subscriptionService", () => ({
getActiveTenantSubscriptions: vi.fn(async () => null),
}));
vi.mock("./step-registry/gating.server", async (importOriginal) => {
const actual = await importOriginal<typeof import("./step-registry/gating.server")>();
return {
...actual,
evaluateOnboardingStepGates: vi.fn(),
};
});
const mockedGetOnboardingSessionsByUser = vi.mocked(getOnboardingSessionsByUser);
const mockedGetOnboardingSession = vi.mocked(getOnboardingSession);
const mockedGetOnboardings = vi.mocked(getOnboardings);
const mockedCreateOnboardingSession = vi.mocked(createOnboardingSession);
const mockedMatches = vi.mocked(OnboardingFiltersService.matches);
const mockedStarted = vi.mocked(OnboardingSessionService.started);
const mockedEvaluateOnboardingStepGates = vi.mocked(evaluateOnboardingStepGates);
const request = new Request("https://app.test/onboarding");
const userId = "user-1";
function filter(id: string, type: string, value: string | null = null): OnboardingFilter {
return {
id,
onboardingId: "onboarding-1",
type,
value,
createdAt: new Date("2025-01-01T00:00:00.000Z"),
updatedAt: new Date("2025-01-01T00:00:00.000Z"),
} as OnboardingFilter;
}
function session(overrides: Partial<OnboardingSession> & { id: string; tenantId: string | null; status?: string }) {
return {
id: overrides.id,
onboardingId: overrides.onboardingId ?? "onboarding-1",
userId: overrides.userId ?? userId,
tenantId: overrides.tenantId,
status: overrides.status ?? "active",
createdRealtime: overrides.createdRealtime ?? true,
startedAt: null,
completedAt: null,
dismissedAt: null,
createdAt: new Date("2025-01-01T00:00:00.000Z"),
updatedAt: new Date("2025-01-01T00:00:00.000Z"),
onboarding: { id: overrides.onboardingId ?? "onboarding-1", active: true, title: "Realtime onboarding" },
user: { id: overrides.userId ?? userId, email: "user-1@example.test" },
tenant: null,
sessionSteps: [],
actions: [],
matches: [],
} as any;
}
function onboarding(filters: OnboardingFilter[], sessions: OnboardingSession[] = []) {
return {
id: "onboarding-1",
title: "Realtime onboarding",
type: "modal",
active: true,
realtime: true,
canBeDismissed: true,
height: "md",
createdAt: new Date("2025-01-01T00:00:00.000Z"),
updatedAt: new Date("2025-01-01T00:00:00.000Z"),
filters,
steps: [{ id: "step-1", onboardingId: "onboarding-1", order: 1, block: "{}", createdAt: new Date(), updatedAt: new Date() }],
sessions,
} as any;
}
describe("OnboardingService single-user tenant flow", () => {
beforeEach(() => {
vi.clearAllMocks();
mockedMatches.mockResolvedValue(true);
mockedEvaluateOnboardingStepGates.mockResolvedValue([
{
step: { id: "profile-basics", title: "Profile basics", description: "Ungated profile setup" },
allowed: true,
},
]);
});
it("can start separate admin and tenant-scoped active sessions for the same user", async () => {
const adminSession = session({ id: "session-admin", tenantId: null });
const tenantSession = session({ id: "session-tenant", tenantId: "tenant-1" });
mockedGetOnboardingSessionsByUser
.mockResolvedValueOnce([adminSession])
.mockResolvedValueOnce([tenantSession]);
const adminResult = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: null, request });
const tenantResult = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: "tenant-1", request });
expect(mockedGetOnboardingSessionsByUser).toHaveBeenNthCalledWith(1, { userId, tenantId: null });
expect(mockedGetOnboardingSessionsByUser).toHaveBeenNthCalledWith(2, { userId, tenantId: "tenant-1" });
expect(adminResult?.id).toBe("session-admin");
expect(tenantResult?.id).toBe("session-tenant");
expect(getVisibleOnboardingSteps(await mockedEvaluateOnboardingStepGates.mock.results[0].value)).toHaveLength(1);
expect(mockedEvaluateOnboardingStepGates).toHaveBeenNthCalledWith(
2,
expect.objectContaining({ request, params: { tenantId: "tenant-1" }, subscription: null })
);
expect(mockedStarted).toHaveBeenCalledWith({ session: adminSession, request });
expect(mockedStarted).toHaveBeenCalledWith({ session: tenantSession, request });
});
it("generates a tenant session when an existing same-user session belongs to another tenant", async () => {
const tenantFilter = filter("filter-tenant", "tenant.portal");
const createdSession = session({ id: "session-created-tenant", tenantId: "tenant-1" });
mockedGetOnboardingSessionsByUser.mockResolvedValueOnce([]);
mockedGetOnboardings.mockResolvedValueOnce([onboarding([tenantFilter], [session({ id: "session-admin", tenantId: null })])]);
mockedCreateOnboardingSession.mockResolvedValueOnce(createdSession as OnboardingSession);
mockedGetOnboardingSession.mockResolvedValueOnce(createdSession);
const result = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: "tenant-1", request });
expect(mockedMatches).toHaveBeenCalledWith({ userId, tenantId: "tenant-1", filter: tenantFilter });
expect(mockedCreateOnboardingSession).toHaveBeenCalledWith(
expect.objectContaining({ id: "onboarding-1" }),
expect.objectContaining({
userId,
tenantId: "tenant-1",
status: "active",
matchingFilters: [tenantFilter],
createdRealtime: true,
})
);
expect(mockedGetOnboardingSession).toHaveBeenCalledWith("session-created-tenant");
expect(mockedStarted).toHaveBeenCalledWith({ session: createdSession, request });
expect(result?.id).toBe("session-created-tenant");
});
it("does not create a realtime session when the existing session has the same tenant", async () => {
const tenantFilter = filter("filter-tenant", "tenant.portal");
mockedGetOnboardingSessionsByUser.mockResolvedValueOnce([]);
mockedGetOnboardings.mockResolvedValueOnce([onboarding([tenantFilter], [session({ id: "session-existing-tenant", tenantId: "tenant-1" })])]);
const result = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: "tenant-1", request });
expect(result).toBeNull();
expect(mockedCreateOnboardingSession).not.toHaveBeenCalled();
expect(mockedGetOnboardingSession).not.toHaveBeenCalled();
expect(mockedStarted).not.toHaveBeenCalled();
});
it("starts and returns an active session when registry gates keep at least one step visible", async () => {
const activeSession = session({ id: "session-visible", tenantId: "tenant-1" });
mockedGetOnboardingSessionsByUser.mockResolvedValueOnce([activeSession]);
mockedEvaluateOnboardingStepGates.mockResolvedValueOnce([
{
step: { id: "profile-basics", title: "Profile basics", description: "Ungated profile setup" },
allowed: true,
},
{
step: { id: "team-invites", title: "Team invites", description: "Feature gated team invites", featureFlagKey: "workspace-roles" },
allowed: false,
diagnostic: { stepId: "team-invites", source: "feature-flag", reason: "feature-disabled", redirectPath: "/feature-disabled" },
},
]);
const result = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: "tenant-1", request });
expect(result?.id).toBe("session-visible");
expect(mockedEvaluateOnboardingStepGates).toHaveBeenCalledWith(expect.objectContaining({ request, params: { tenantId: "tenant-1" } }));
expect(mockedStarted).toHaveBeenCalledWith({ session: activeSession, request });
});
it("returns null and does not start an active session when registry gates deny every step", async () => {
const activeSession = session({ id: "session-denied", tenantId: "tenant-1" });
mockedGetOnboardingSessionsByUser.mockResolvedValueOnce([activeSession]);
mockedEvaluateOnboardingStepGates.mockResolvedValueOnce([
{
step: { id: "team-invites", title: "Team invites", description: "Feature gated team invites", featureFlagKey: "workspace-roles" },
allowed: false,
diagnostic: { stepId: "team-invites", source: "feature-flag", reason: "feature-disabled", redirectPath: "/feature-disabled" },
},
{
step: { id: "priority-support-setup", title: "Priority support setup", description: "Plan gated priority support", planFeatureKey: "priority-support" },
allowed: false,
diagnostic: { stepId: "priority-support-setup", source: "plan", reason: "plan-required", redirectPath: "plan-required" },
},
]);
const result = await OnboardingService.getUserActiveOnboarding({ userId, tenantId: "tenant-1", request });
expect(result).toBeNull();
expect(mockedEvaluateOnboardingStepGates).toHaveBeenCalledWith(expect.objectContaining({ request, params: { tenantId: "tenant-1" } }));
expect(mockedStarted).not.toHaveBeenCalled();
});
});