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

240 lines
10 KiB
TypeScript

// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
import { PricingModel } from "~/application/enums/subscriptions/PricingModel";
import { SubscriptionBillingPeriod } from "~/application/enums/subscriptions/SubscriptionBillingPeriod";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("~/components/core/settings/subscription/plans/PlansGrouped", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/ErrorModal", () => ({ default: () => null }));
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn(() => true) }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
requireUserId: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/db/tenantSubscriptions.db.server", () => ({
createTenantSubscription: vi.fn(),
getTenantSubscription: vi.fn(),
updateTenantSubscriptionCustomerId: vi.fn(),
}));
vi.mock("~/utils/db/subscriptionProducts.db.server", () => ({
getSubscriptionProduct: vi.fn(),
}));
vi.mock("~/utils/stripe.server", () => ({
createStripeCheckoutSession: vi.fn(),
createStripeCustomer: vi.fn(),
getStripeCoupon: vi.fn(),
}));
vi.mock("~/utils/url.server", () => ({
getAbsoluteCurrentUrl: vi.fn(),
getAbsoluteUrl: vi.fn(),
}));
vi.mock("~/utils/data/.server/appData", () => ({ loadAppData: vi.fn() }));
vi.mock("@toolctrl/db/subscriptions.server", () => ({
getAllSubscriptionProducts: vi.fn(),
getSubscriptionProductsInIds: vi.fn(),
}));
vi.mock("@toolctrl/config", () => ({
loadRequiredWebConfig: vi.fn(() => ({ routing: {} })),
}));
import { getTranslations } from "~/locale/i18next.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { getTenantSubscription, createTenantSubscription, updateTenantSubscriptionCustomerId } from "~/utils/db/tenantSubscriptions.db.server";
import { getSubscriptionProduct } from "~/utils/db/subscriptionProducts.db.server";
import { createStripeCheckoutSession, createStripeCustomer } from "~/utils/stripe.server";
import { getAbsoluteCurrentUrl, getAbsoluteUrl } from "~/utils/url.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { requireUserId, validateCSRFToken } from "~/utils/session.server";
import { action } from "./subscribe.$tenant";
const params = { tenant: "acme" };
const tenant = { id: "tenant-1", name: "Acme Inc.", slug: "acme" };
const user = { id: "user-1", email: "ada@example.test" };
const product = {
id: "product-pro",
title: "Pro",
model: PricingModel.FLAT_RATE,
billingAddressCollection: "auto",
prices: [
{
id: "price-db-1",
stripeId: "price_stripe_monthly",
currency: "usd",
billingPeriod: SubscriptionBillingPeriod.MONTHLY,
trialDays: 14,
},
],
usageBasedPrices: [],
};
function createForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "subscribe");
form.set("product-id", product.id);
form.set("billing-period", SubscriptionBillingPeriod.MONTHLY.toString());
form.set("currency", "usd");
form.set("quantity", "3");
form.set("tenant-slug-context", params.tenant);
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
function createRequest(form: FormData) {
return new Request("https://app.example.test/subscribe/acme", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
async function callAction(form: FormData) {
return action({
request: createRequest(form),
params,
context: {},
unstable_pattern: "subscribe.$tenant",
} as ActionFunctionArgs) as Promise<Response>;
}
async function json(response: Response) {
return response.json() as Promise<Record<string, unknown>>;
}
describe("subscribe.$tenant action checkout wiring", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTranslations).mockResolvedValue({
t: (key: string, values?: Record<string, unknown>) => {
const translations: Record<string, string> = {
"settings.subscription.checkout.tenantMismatch":
'Tenant mismatch: the form was rendered for "{{formTenantSlug}}" but submitted to "{{submittedTenantSlug}}". Refresh the page and try again.',
"settings.subscription.checkout.updateFailed": "Could not update subscription.",
"settings.subscription.errors.invalidStripeCustomer": "Invalid Stripe customer",
};
const template = translations[key];
if (template) {
return template.replace(/\{\{(\w+)\}\}/gu, (_match, name: string) => String(values?.[name] ?? ""));
}
return key;
},
} as never);
vi.mocked(requireUserId).mockResolvedValue(user.id as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getUser).mockResolvedValue(user as never);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(getTenantSubscription).mockResolvedValue({ tenantId: tenant.id, stripeCustomerId: "cus_existing" } as never);
vi.mocked(createTenantSubscription).mockResolvedValue({ tenantId: tenant.id, stripeCustomerId: "" } as never);
vi.mocked(updateTenantSubscriptionCustomerId).mockResolvedValue({ tenantId: tenant.id, stripeCustomerId: "cus_created" } as never);
vi.mocked(getSubscriptionProduct).mockResolvedValue(product as never);
vi.mocked(createStripeCustomer).mockResolvedValue({ id: "cus_created" } as never);
vi.mocked(createStripeCheckoutSession).mockResolvedValue({ id: "cs_123", url: "https://checkout.stripe.test/session/cs_123" } as never);
vi.mocked(getAbsoluteUrl).mockImplementation((_request: Request, path: string) => `https://app.example.test${path}`);
vi.mocked(getAbsoluteCurrentUrl).mockReturnValue("https://app.example.test/subscribe/acme");
});
it("redirects an existing Stripe customer to the checkout URL", async () => {
const response = await callAction(createForm());
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("https://checkout.stripe.test/session/cs_123");
expect(createStripeCustomer).not.toHaveBeenCalled();
expect(updateTenantSubscriptionCustomerId).not.toHaveBeenCalled();
expect(createStripeCheckoutSession).toHaveBeenCalledWith(
expect.objectContaining({
customer: "cus_existing",
line_items: [{ price: "price_stripe_monthly", quantity: 3 }],
mode: "subscription",
success_url: "https://app.example.test/subscribe/acme/{CHECKOUT_SESSION_ID}/success",
cancel_url: "https://app.example.test/subscribe/acme",
freeTrialDays: 14,
})
);
});
it("creates and persists a missing Stripe customer before checkout", async () => {
vi.mocked(getTenantSubscription).mockResolvedValueOnce(null as never);
const response = await callAction(createForm());
expect(response.status).toBe(302);
expect(createTenantSubscription).toHaveBeenCalledWith(tenant.id, "");
expect(createStripeCustomer).toHaveBeenCalledWith(user.email, tenant.name);
expect(updateTenantSubscriptionCustomerId).toHaveBeenCalledWith(tenant.id, { stripeCustomerId: "cus_created" });
expect(createStripeCheckoutSession).toHaveBeenCalledWith(expect.objectContaining({ customer: "cus_created" }));
expect(vi.mocked(updateTenantSubscriptionCustomerId).mock.invocationCallOrder[0]).toBeLessThan(
vi.mocked(createStripeCheckoutSession).mock.invocationCallOrder[0]
);
});
it("rejects stale tenant slug context before calling Stripe", async () => {
const response = await callAction(createForm({ "tenant-slug-context": "old-acme" }));
const data = await json(response);
expect(response.status).toBe(400);
expect(data.error).toContain("Tenant mismatch");
expect(getTenantSubscription).not.toHaveBeenCalled();
expect(createStripeCustomer).not.toHaveBeenCalled();
expect(createStripeCheckoutSession).not.toHaveBeenCalled();
});
it("returns a translated invalid-customer failure without exposing Stripe details", async () => {
vi.mocked(getTenantSubscription).mockResolvedValueOnce({ tenantId: tenant.id, stripeCustomerId: "" } as never);
vi.mocked(createStripeCustomer).mockResolvedValueOnce(null as never);
const response = await callAction(createForm());
const data = await json(response);
expect(response.status).toBe(400);
expect(data).toEqual({ error: "Invalid Stripe customer" });
expect(createStripeCheckoutSession).not.toHaveBeenCalled();
});
it("stops checkout mutation when CSRF validation fails", async () => {
const csrfError = new Error("CSRF tokens do not match");
vi.mocked(validateCSRFToken).mockRejectedValueOnce(csrfError as never);
await expect(callAction(createForm())).rejects.toBe(csrfError);
expect(verifyUserHasPermission).not.toHaveBeenCalled();
expect(getTenantSubscription).not.toHaveBeenCalled();
expect(createTenantSubscription).not.toHaveBeenCalled();
expect(createStripeCustomer).not.toHaveBeenCalled();
expect(updateTenantSubscriptionCustomerId).not.toHaveBeenCalled();
expect(createStripeCheckoutSession).not.toHaveBeenCalled();
});
it("returns a safe 400 failure when checkout session creation has no URL", async () => {
vi.mocked(createStripeCheckoutSession).mockResolvedValueOnce({ id: "cs_without_url", url: null } as never);
const response = await callAction(createForm());
const data = await json(response);
expect(response.status).toBe(400);
expect(data).toEqual({ error: "Could not update subscription." });
expect(JSON.stringify(data)).not.toContain("cs_without_url");
expect(createStripeCheckoutSession).toHaveBeenCalledTimes(1);
});
});