import { describe, expect, it } from "vitest"; import { entitlementLimitTypes, featureGateRegistry, getFeatureGate, getStandardEntitlementPlan, getBillingProviderPricePlaceholder, getBillingProviderProductPlaceholder, listStandardEntitlementPlanIds, standardEntitlementPlans, type EntitlementPlanFeatureAssignment, type FeatureKey, } from "./index.js"; const expectedPlanIds = ["starter", "pro", "business"] as const; const expectedFeatureKeys = [ "dashboard", "crm-basic", "leads", "projects", "support-tickets", "knowledge-base-read", "knowledge-base-tenant", "files", "users", "tasks", "hr", "integrations", "booking", "forms", "signature", "billing", "search", "automation", "api", "email-marketing", "imported-lists", "crm-based-lists", "onboarding", "workflow-engine", "mcp", "advanced-builder", "import-export", "email-inbox", "rate-limit-per-minute", "rate-limit-per-second", "priority-support", "ai-credits", "private-generations", ] as const satisfies readonly FeatureKey[]; const unsafeFixturePattern = /(?:prod_[a-z0-9]|price_[a-z0-9]|sk_(?:live|test)|pk_(?:live|test)|api[_ -]?key|secret|password|token|tenant[_ -]?id|customer[_ -]?id|subscription[_ -]?id|acct_[a-z0-9]|cus_[a-z0-9]|sub_[a-z0-9])/i; function limitTypeName(limitType: number): string | undefined { return Object.entries(entitlementLimitTypes).find(([, value]) => value === limitType)?.[0]; } function assignmentStrings(assignment: EntitlementPlanFeatureAssignment): readonly string[] { return [assignment.featureKey, assignment.label, String(assignment.limit ?? ""), String(assignment.order), String(assignment.limitType)]; } describe("standardEntitlementPlans", () => { it("exports public standard plans in deterministic order", () => { expect(listStandardEntitlementPlanIds()).toEqual(expectedPlanIds); expect(standardEntitlementPlans.map((plan) => plan.metadata.sortOrder)).toEqual([10, 20, 30]); expect(standardEntitlementPlans.map((plan) => plan.metadata.slug)).toEqual(expectedPlanIds); expect(standardEntitlementPlans.every((plan) => plan.metadata.isPublic)).toBe(true); }); it("uses unique plan IDs and immutable plan fixtures", () => { const planIds = listStandardEntitlementPlanIds(); expect(new Set(planIds).size).toBe(planIds.length); expect(Object.isFrozen(standardEntitlementPlans)).toBe(true); for (const plan of standardEntitlementPlans) { expect(Object.isFrozen(plan)).toBe(true); expect(Object.isFrozen(plan.metadata)).toBe(true); expect(Object.isFrozen(plan.features)).toBe(true); } }); it("covers every registered standard feature in every public plan", () => { for (const plan of standardEntitlementPlans) { expect( plan.features.map((feature) => feature.featureKey), `${plan.id} feature coverage` ).toEqual(expectedFeatureKeys); expect( plan.features.map((feature) => feature.featureKey), `${plan.id} registry coverage` ).toEqual(featureGateRegistry.map((feature) => feature.key)); } }); it("keeps plan feature assignments in registry order", () => { const expectedOrders = featureGateRegistry.map((feature) => feature.defaultOrder); for (const plan of standardEntitlementPlans) { expect( plan.features.map((feature) => feature.order), `${plan.id} feature order` ).toEqual(expectedOrders); } }); it("references only known feature keys and supported limit types", () => { for (const plan of standardEntitlementPlans) { for (const assignment of plan.features) { const featureGate = getFeatureGate(assignment.featureKey); const registryLimitType = limitTypeName(assignment.limitType); expect(featureGate, `${plan.id}.${assignment.featureKey} known feature`).toBeDefined(); expect(registryLimitType, `${plan.id}.${assignment.featureKey} limit type name`).toBeDefined(); expect(featureGate?.supportedLimitTypes, `${plan.id}.${assignment.featureKey} supported limit type`).toContain( registryLimitType?.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`) ); } } }); it("exposes lookup helpers without mutating fixture order", () => { expect(getStandardEntitlementPlan("pro")?.metadata.publicName).toBe("Pro"); expect(getStandardEntitlementPlan("pro")?.metadata.billingProviderProductId).toBe(getBillingProviderProductPlaceholder("pro")); expect(getStandardEntitlementPlan("pro")?.metadata.billingProviderPriceId).toBe(getBillingProviderPricePlaceholder("pro")); expect(getStandardEntitlementPlan("unknown-plan")).toBeUndefined(); expect(listStandardEntitlementPlanIds()).toEqual(expectedPlanIds); }); it("uses deterministic safe Mollie placeholders and no secret-looking fixture strings", () => { for (const plan of standardEntitlementPlans) { expect(plan.metadata.billingProviderProductId, `${plan.id} product id placeholder`).toBe(getBillingProviderProductPlaceholder(plan.id)); expect(plan.metadata.billingProviderPriceId, `${plan.id} price id placeholder`).toBe(getBillingProviderPricePlaceholder(plan.id)); expect(plan.metadata.billingProviderProductId, `${plan.id} non-empty product placeholder`).not.toBe(""); expect(plan.metadata.billingProviderPriceId, `${plan.id} non-empty price placeholder`).not.toBe(""); expect(getStandardEntitlementPlan(plan.id)?.metadata.billingProviderProductId, `${plan.id} lookup product placeholder`).toBe(plan.metadata.billingProviderProductId); expect(getStandardEntitlementPlan(plan.id)?.metadata.billingProviderPriceId, `${plan.id} lookup price placeholder`).toBe(plan.metadata.billingProviderPriceId); const strings = [ plan.id, plan.metadata.slug, plan.metadata.publicName, plan.metadata.description, plan.metadata.billingProviderProductId, plan.metadata.billingProviderPriceId, ...plan.features.flatMap(assignmentStrings), ]; for (const value of strings) { expect(value, `${plan.id} safe fixture value`).not.toMatch(unsafeFixturePattern); } } }); });