import { beforeEach, describe, expect, it, vi } from "vitest"; import type { OnboardingFilter, OnboardingSession } from "@hivegrid/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/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(); 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 & { 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(); }); });