250 lines
10 KiB
TypeScript
250 lines
10 KiB
TypeScript
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<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();
|
|
});
|
|
});
|