Files

190 lines
6.7 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { OnboardingSessionWithDetails } from "../db/onboardingSessions.db.server";
import OnboardingSessionService from "./OnboardingSessionService";
import EventsService from "~/modules/events/services/.server/EventsService";
import { setOnboardingSessionActions, updateOnboardingSession } from "../db/onboardingSessions.db.server";
import { updateOnboardingSessionStep } from "../db/onboardingSessionSteps.db.server";
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: {
create: vi.fn(),
},
}));
vi.mock("../db/onboardingSessions.db.server", () => ({
setOnboardingSessionActions: vi.fn(),
updateOnboardingSession: vi.fn(),
}));
vi.mock("../db/onboardingSessionSteps.db.server", () => ({
updateOnboardingSessionStep: vi.fn(),
}));
const mockedCreateEvent = vi.mocked(EventsService.create);
const mockedUpdateOnboardingSession = vi.mocked(updateOnboardingSession);
const mockedSetOnboardingSessionActions = vi.mocked(setOnboardingSessionActions);
const mockedUpdateOnboardingSessionStep = vi.mocked(updateOnboardingSessionStep);
const request = new Request("https://app.example.test/onboarding/session");
// Keeps TC candidate reruns unblocked after correcting the candidate's app-relative lint path.
function session(overrides: Partial<OnboardingSessionWithDetails> = {}): OnboardingSessionWithDetails {
return {
id: "session-tenant-1",
onboardingId: "onboarding-1",
userId: "user-tenant-1",
tenantId: "tenant-1",
status: "active",
createdRealtime: true,
startedAt: null,
completedAt: null,
dismissedAt: null,
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-01T00:00:00.000Z"),
onboarding: {
id: "onboarding-1",
title: "Tenant onboarding",
active: true,
type: "modal",
realtime: true,
canBeDismissed: true,
height: "md",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-01T00:00:00.000Z"),
} as any,
user: {
id: "user-tenant-1",
email: "tenant-user@example.test",
} as any,
tenant: null,
sessionSteps: [
{
id: "session-step-1",
onboardingSessionId: "session-tenant-1",
onboardingStepId: "step-1",
seenAt: null,
completedAt: null,
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-01T00:00:00.000Z"),
step: {
id: "step-1",
onboardingId: "onboarding-1",
order: 1,
block: "{}",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-01T00:00:00.000Z"),
} as any,
} as any,
],
actions: [],
matches: [],
...overrides,
} as OnboardingSessionWithDetails;
}
function expectTenantEvent(event: "onboarding.started" | "onboarding.completed" | "onboarding.dismissed") {
expect(mockedCreateEvent).toHaveBeenCalledTimes(1);
expect(mockedCreateEvent).toHaveBeenCalledWith({
request,
event,
tenantId: "tenant-1",
userId: "user-tenant-1",
data: {
session: { id: "session-tenant-1" },
onboarding: { title: "Tenant onboarding" },
user: { id: "user-tenant-1", email: "tenant-user@example.test" },
},
});
}
describe("OnboardingSessionService tenant event propagation", () => {
beforeEach(() => {
vi.useFakeTimers();
vi.clearAllMocks();
mockedUpdateOnboardingSession.mockResolvedValue({} as any);
mockedUpdateOnboardingSessionStep.mockResolvedValue({} as any);
mockedSetOnboardingSessionActions.mockResolvedValue({} as any);
mockedCreateEvent.mockResolvedValue({} as any);
});
afterEach(() => {
vi.useRealTimers();
});
it("emits tenant diagnostics when a session starts", async () => {
await OnboardingSessionService.started({ request, session: session() });
expect(mockedUpdateOnboardingSession).toHaveBeenCalledWith("session-tenant-1", {
status: "started",
startedAt: expect.any(Date),
});
expectTenantEvent("onboarding.started");
});
it("does not emit a duplicate started event for an already-started session", async () => {
await OnboardingSessionService.started({ request, session: session({ startedAt: new Date("2026-01-02T00:00:00.000Z") }) });
expect(mockedUpdateOnboardingSession).not.toHaveBeenCalled();
expect(mockedCreateEvent).not.toHaveBeenCalled();
});
it("does not write a tenantless application event for pre-tenant onboarding", async () => {
await OnboardingSessionService.started({ request, session: session({ tenantId: null }) });
expect(mockedUpdateOnboardingSession).toHaveBeenCalled();
expect(mockedCreateEvent).not.toHaveBeenCalled();
});
it("emits tenant diagnostics when a session is dismissed", async () => {
await OnboardingSessionService.dismissed({ request, session: session() });
expect(mockedUpdateOnboardingSession).toHaveBeenCalledWith("session-tenant-1", {
status: "dismissed",
dismissedAt: expect.any(Date),
});
expectTenantEvent("onboarding.dismissed");
});
it("does not emit a duplicate dismissed event for an already-dismissed session", async () => {
await OnboardingSessionService.dismissed({ request, session: session({ dismissedAt: new Date("2026-01-02T00:00:00.000Z") }) });
expect(mockedUpdateOnboardingSession).not.toHaveBeenCalled();
expect(mockedCreateEvent).not.toHaveBeenCalled();
});
it("emits tenant diagnostics when a session completes", async () => {
const completion = OnboardingSessionService.complete({ request, session: session(), data: { fromIdx: 0, actions: [] } });
await vi.advanceTimersByTimeAsync(2000);
await completion;
expect(mockedUpdateOnboardingSessionStep).toHaveBeenCalledWith("session-step-1", {
completedAt: expect.any(Date),
});
expect(mockedSetOnboardingSessionActions).not.toHaveBeenCalled();
expect(mockedUpdateOnboardingSession).toHaveBeenCalledWith("session-tenant-1", {
status: "completed",
completedAt: expect.any(Date),
});
expectTenantEvent("onboarding.completed");
});
it("does not emit a duplicate completed event for an already-completed session", async () => {
const completion = OnboardingSessionService.complete({
request,
session: session({ completedAt: new Date("2026-01-02T00:00:00.000Z") }),
data: { fromIdx: 0, actions: [] },
});
await vi.advanceTimersByTimeAsync(2000);
await completion;
expect(mockedUpdateOnboardingSessionStep).toHaveBeenCalledWith("session-step-1", {
completedAt: expect.any(Date),
});
expect(mockedUpdateOnboardingSession).not.toHaveBeenCalled();
expect(mockedCreateEvent).not.toHaveBeenCalled();
});
});