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

182 lines
8.7 KiB
TypeScript

// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
const mocks = vi.hoisted(() => ({
getTranslations: vi.fn(),
getTenantIdFromUrl: vi.fn(),
verifyUserHasPermission: vi.fn(),
getUserInfo: vi.fn(),
getUser: vi.fn(),
getTenant: vi.fn(),
getOrPersistTenantSubscription: vi.fn(),
getTenantSubscription: vi.fn(),
getStripeCustomer: vi.fn(),
getStripeInvoices: vi.fn(),
getStripePaymentIntents: vi.fn(),
getStripeUpcomingInvoices: vi.fn(),
getStripePaymentMethods: vi.fn(),
createCustomerPortalSession: vi.fn(),
cancelTenantSubscription: vi.fn(),
getPlanFeaturesUsage: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
vi.mock("react-hot-toast", () => ({ default: { error: vi.fn(), success: vi.fn() } }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/modules/users/components/SubscriptionSettings", () => ({ default: () => null }));
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn(() => true) }));
vi.mock("~/utils/data/useAppData", () => ({ useAppData: vi.fn(() => ({ mySubscription: null, currentTenant: { slug: "acme" } })) }));
vi.mock("~/modules/metrics/services/.server/MetricTracker", () => ({
createMetrics: vi.fn(async () => ({
time: async (value: unknown) => await value,
getServerTimingHeader: () => ({}),
})),
}));
vi.mock("~/modules/metrics/utils/defaultHeaders", () => ({ serverTimingHeaders: vi.fn() }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: (...args: unknown[]) => mocks.getTranslations(...args) }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: (...args: unknown[]) => mocks.getTenantIdFromUrl(...args) }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: (...args: unknown[]) => mocks.verifyUserHasPermission(...args) }));
vi.mock("~/utils/session.server", () => ({
getUserInfo: (...args: unknown[]) => mocks.getUserInfo(...args),
validateCSRFToken: (...args: unknown[]) => mocks.validateCSRFToken(...args),
}));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: (...args: unknown[]) => mocks.getUser(...args) }));
vi.mock("~/utils/db/tenants.db.server", () => ({ getTenant: (...args: unknown[]) => mocks.getTenant(...args) }));
vi.mock("~/utils/db/tenantSubscriptions.db.server", () => ({
getOrPersistTenantSubscription: (...args: unknown[]) => mocks.getOrPersistTenantSubscription(...args),
getTenantSubscription: (...args: unknown[]) => mocks.getTenantSubscription(...args),
}));
vi.mock("~/utils/services/.server/subscriptionService", () => ({
cancelTenantSubscription: (...args: unknown[]) => mocks.cancelTenantSubscription(...args),
getPlanFeaturesUsage: (...args: unknown[]) => mocks.getPlanFeaturesUsage(...args),
}));
vi.mock("~/utils/stripe.server", () => ({
createCustomerPortalSession: (...args: unknown[]) => mocks.createCustomerPortalSession(...args),
createStripeSetupSession: vi.fn(),
deleteStripePaymentMethod: vi.fn(),
getStripeCustomer: (...args: unknown[]) => mocks.getStripeCustomer(...args),
getStripeInvoices: (...args: unknown[]) => mocks.getStripeInvoices(...args),
getStripePaymentIntents: (...args: unknown[]) => mocks.getStripePaymentIntents(...args),
getStripeUpcomingInvoices: (...args: unknown[]) => mocks.getStripeUpcomingInvoices(...args),
getStripePaymentMethods: (...args: unknown[]) => mocks.getStripePaymentMethods(...args),
}));
import { action, loader } from "./subscription";
const tenantId = "tenant-1";
const userId = "user-1";
const params = { tenant: "acme" };
const tenantSubscription = {
stripeCustomerId: "cus_123",
products: [{ stripeSubscriptionId: "sub_123" }],
};
function formRequest(form: FormData) {
return new Request("https://app.example.test/app/acme/settings/subscription", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
function createForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "open-customer-portal");
form.set("csrf", "csrf-token");
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: formRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/subscription",
} as ActionFunctionArgs) as Promise<Response>;
}
describe("tenant subscription settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.getTranslations.mockResolvedValue({ t: (key: string) => key });
mocks.getTenantIdFromUrl.mockResolvedValue(tenantId);
mocks.verifyUserHasPermission.mockResolvedValue(undefined);
mocks.getUserInfo.mockResolvedValue({ userId });
mocks.getUser.mockResolvedValue({ id: userId, email: "user@example.test" });
mocks.getTenant.mockResolvedValue({ id: tenantId, name: "Acme", slug: "acme" });
mocks.getOrPersistTenantSubscription.mockResolvedValue(tenantSubscription);
mocks.getTenantSubscription.mockResolvedValue(tenantSubscription);
mocks.getStripeCustomer.mockResolvedValue({ id: "cus_123" });
mocks.getStripeInvoices.mockResolvedValue([{ id: "in_1" }]);
mocks.getStripePaymentIntents.mockResolvedValue([{ id: "pi_1" }]);
mocks.getStripeUpcomingInvoices.mockResolvedValue([{ id: "in_upcoming" }]);
mocks.getStripePaymentMethods.mockResolvedValue([{ id: "pm_1" }]);
mocks.getPlanFeaturesUsage.mockResolvedValue([{ name: "seats" }]);
mocks.validateCSRFToken.mockResolvedValue(undefined);
mocks.createCustomerPortalSession.mockResolvedValue({ url: "https://billing.stripe.test/session" });
mocks.cancelTenantSubscription.mockResolvedValue(undefined);
});
it("does not call Stripe invoice APIs when invoice permission is denied", async () => {
mocks.verifyUserHasPermission.mockImplementation(async (_request: Request, permission: string) => {
if (permission === "app.settings.subscription.invoices.view") throw new Response("Forbidden", { status: 403 });
});
const response = await loader({
request: new Request("https://app.example.test/app/acme/settings/subscription"),
params,
context: {},
unstable_pattern: "app.$tenant/settings/subscription",
} as LoaderFunctionArgs);
const data = await response.json();
expect(data.customer).toBeNull();
expect(data.myInvoices).toEqual([]);
expect(data.myPayments).toEqual([]);
expect(data.myUpcomingInvoices).toEqual([]);
expect(data.myPaymentMethods).toEqual([]);
expect(data.myFeatures).toEqual([{ name: "seats" }]);
expect(mocks.getStripeCustomer).not.toHaveBeenCalled();
expect(mocks.getStripeInvoices).not.toHaveBeenCalled();
expect(mocks.getStripePaymentIntents).not.toHaveBeenCalled();
expect(mocks.getStripeUpcomingInvoices).not.toHaveBeenCalled();
expect(mocks.getStripePaymentMethods).not.toHaveBeenCalled();
});
it("returns 400 instead of redirecting to an empty customer portal URL", async () => {
mocks.createCustomerPortalSession.mockResolvedValueOnce({ url: "" });
const response = await callAction(createForm());
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ error: "settings.subscription.errors.customerPortalUnavailable" });
});
it("checks delete permission before cancelling a subscription product", async () => {
const response = await callAction(createForm({ action: "cancel", "tenant-subscription-product-id": "tsp_1" }));
expect(response.status).toBe(200);
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.subscription.update", tenantId);
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.subscription.delete", tenantId);
expect(mocks.cancelTenantSubscription).toHaveBeenCalledWith("tsp_1", expect.objectContaining({ tenantId, userId }));
});
it("keeps cancel internals out of tenant-facing errors", async () => {
mocks.cancelTenantSubscription.mockRejectedValueOnce(new Error("Stripe raw failure"));
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
const response = await callAction(createForm({ action: "cancel", "tenant-subscription-product-id": "tsp_1" }));
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ error: "shared.unexpectedError" });
expect(JSON.stringify(data)).not.toContain("Stripe raw failure");
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
consoleError.mockRestore();
});
});