feat: added tests

Author: mvriu5

package.json

@@ -16,6 +16,7 @@
         "lint": "npm run typecheck",
         "typecheck": "tsc --noEmit",
         "knip": "node --import tsx ./node_modules/knip/bin/knip.js",
+        "test": "node --import tsx --test tests/*.test.ts",
         "generate": "payload generate:types"
     },
     "dependencies": {

src/components/SubscriptionConfigurator.tsx

@@ -3,6 +3,7 @@
 import type { SubscriptionConfigData } from "@/lib/cms"
 import { formatEuroCurrency } from "@/lib/formatters"
 import type { AppLocale } from "@/lib/i18n"
+import { calculateSubscriptionPrice, clampToRange, formatDiscountBadge, getPaymentPeriodDiscount, getPaymentPeriodSuffix, type PaymentPeriod, type UsageRange } from "@/lib/subscriptionCalculator"
 import { useDesktopPinnedPosition } from "@/hooks/useDesktopPinnedPosition"
 import { cn } from "@/lib/utils"
 import { BuyMenu } from "@/components/BuyMenu"
@@ -17,7 +18,6 @@ import { Card } from "./ui/Card"
 
 type DeploymentMode = "self-hosted" | "cloud"
 type CustomerType = "b2b" | "b2c"
-type PaymentPeriod = "monthly" | "quarterly" | "yearly"
 type OptionAccent = "aqua" | "yellow" | "pink" | "blue" | "brand"
 type SubscriptionSelection = {
     deployment: DeploymentMode
@@ -26,12 +26,6 @@ type SubscriptionSelection = {
     workflowExecutions: number
     aiTokens: number
 }
-type UsageRange = {
-    min: number
-    max: number
-    step: number
-}
-
 export interface SubscriptionIcons {
     featureOverview: ReactNode[]
     deployment: {
@@ -182,29 +176,6 @@ function AdditionalFeatureCard({ title, description, active, onClick, icon, form
     )
 }
 
-function clampToRange(value: number, range: UsageRange) {
-    return Math.min(Math.max(value, range.min), range.max)
-}
-
-function formatDiscountBadge(discount: number, locale: AppLocale) {
-    return new Intl.NumberFormat(locale === "de" ? "de-DE" : "en-US", {
-        style: "percent",
-        maximumFractionDigits: 0,
-    }).format(discount)
-}
-
-function getPaymentPeriodDiscount(period: PaymentPeriod, paymentPeriod: SubscriptionConfigData["paymentPeriod"]) {
-    if (period === "quarterly") return paymentPeriod.quarterlyDiscount
-    if (period === "yearly") return paymentPeriod.yearlyDiscount
-    return 0
-}
-
-function getPaymentPeriodSuffix(period: PaymentPeriod, paymentPeriod: SubscriptionConfigData["paymentPeriod"]) {
-    if (period === "quarterly") return paymentPeriod.quarterlyPeriodSuffix
-    if (period === "yearly") return paymentPeriod.yearlyPeriodSuffix
-    return paymentPeriod.monthlyPeriodSuffix
-}
-
 export function SubscriptionConfigurator({ locale, content, icons }: { locale: AppLocale; content: SubscriptionConfigData; icons: SubscriptionIcons }) {
     const workflowExecutions = content.workflowExecutions
     const aiTokens = content.aiTokens
@@ -226,13 +197,17 @@ export function SubscriptionConfigurator({ locale, content, icons }: { locale: A
     const [selectedFeatures, setSelectedFeatures] = useState<Set<number>>(new Set())
     const { wrapperRef: desktopWrapperRef, containerRef: desktopContainerRef } = useDesktopPinnedPosition<HTMLDivElement, HTMLDivElement>(96)
 
-    const workflowExecutionPrice = content.workflowExecutionPriceFactor * selection.workflowExecutions
-    const aiTokenPrice = content.aiTokenPriceFactor * selection.aiTokens
     const additionalFeaturesPrice = Array.from(selectedFeatures).reduce((acc, idx) => acc + (content.additionalFeatures?.[idx]?.price ?? 0), 0)
     const paymentPeriodDiscount = getPaymentPeriodDiscount(selection.paymentPeriod, content.paymentPeriod)
     const paymentPeriodSuffix = getPaymentPeriodSuffix(selection.paymentPeriod, content.paymentPeriod)
-    const totalBeforeDiscount = workflowExecutionPrice + aiTokenPrice + additionalFeaturesPrice
-    const totalPrice = totalBeforeDiscount * (1 - paymentPeriodDiscount)
+    const { totalPrice } = calculateSubscriptionPrice({
+        additionalFeaturesPrice,
+        aiTokenPriceFactor: content.aiTokenPriceFactor,
+        aiTokens: selection.aiTokens,
+        discount: paymentPeriodDiscount,
+        workflowExecutionPriceFactor: content.workflowExecutionPriceFactor,
+        workflowExecutions: selection.workflowExecutions,
+    })
     const paymentPeriodSwitchOptions: SwitchOption<PaymentPeriod>[] = paymentPeriodOptions.map((option) => {
         const discount = getPaymentPeriodDiscount(option.value, content.paymentPeriod)
 

src/lib/subscriptionCalculator.ts

@@ -0,0 +1,60 @@
+import type { SubscriptionConfigData } from "@/lib/cms"
+import type { AppLocale } from "@/lib/i18n"
+
+export type PaymentPeriod = "monthly" | "quarterly" | "yearly"
+
+export type UsageRange = {
+    min: number
+    max: number
+    step: number
+}
+
+export function clampToRange(value: number, range: UsageRange) {
+    return Math.min(Math.max(value, range.min), range.max)
+}
+
+export function formatDiscountBadge(discount: number, locale: AppLocale) {
+    return new Intl.NumberFormat(locale === "de" ? "de-DE" : "en-US", {
+        style: "percent",
+        maximumFractionDigits: 0,
+    }).format(discount)
+}
+
+export function getPaymentPeriodDiscount(period: PaymentPeriod, paymentPeriod: SubscriptionConfigData["paymentPeriod"]) {
+    if (period === "quarterly") return paymentPeriod.quarterlyDiscount
+    if (period === "yearly") return paymentPeriod.yearlyDiscount
+    return 0
+}
+
+export function getPaymentPeriodSuffix(period: PaymentPeriod, paymentPeriod: SubscriptionConfigData["paymentPeriod"]) {
+    if (period === "quarterly") return paymentPeriod.quarterlyPeriodSuffix
+    if (period === "yearly") return paymentPeriod.yearlyPeriodSuffix
+    return paymentPeriod.monthlyPeriodSuffix
+}
+
+export function calculateSubscriptionPrice({
+    additionalFeaturesPrice = 0,
+    aiTokenPriceFactor,
+    aiTokens,
+    discount = 0,
+    workflowExecutionPriceFactor,
+    workflowExecutions,
+}: {
+    additionalFeaturesPrice?: number
+    aiTokenPriceFactor: number
+    aiTokens: number
+    discount?: number
+    workflowExecutionPriceFactor: number
+    workflowExecutions: number
+}) {
+    const workflowExecutionPrice = workflowExecutionPriceFactor * workflowExecutions
+    const aiTokenPrice = aiTokenPriceFactor * aiTokens
+    const totalBeforeDiscount = workflowExecutionPrice + aiTokenPrice + additionalFeaturesPrice
+
+    return {
+        aiTokenPrice,
+        totalBeforeDiscount,
+        totalPrice: totalBeforeDiscount * (1 - discount),
+        workflowExecutionPrice,
+    }
+}

tests/i18n.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { getLocaleFromPath, isSupportedLocale, localizeHref } from "@/lib/i18n"
+
+test("detects supported locales", () => {
+    assert.equal(isSupportedLocale("en"), true)
+    assert.equal(isSupportedLocale("de"), true)
+    assert.equal(isSupportedLocale("fr"), false)
+})
+
+test("gets locale from path with fallback", () => {
+    assert.equal(getLocaleFromPath("/de/features"), "de")
+    assert.equal(getLocaleFromPath("/en"), "en")
+    assert.equal(getLocaleFromPath("/features"), "en")
+    assert.equal(getLocaleFromPath("/"), "en")
+})
+
+test("localizes internal hrefs only once", () => {
+    assert.equal(localizeHref("/features", "de"), "/de/features")
+    assert.equal(localizeHref("/", "de"), "/de")
+    assert.equal(localizeHref("/en/features", "de"), "/en/features")
+    assert.equal(localizeHref("https://example.com", "de"), "https://example.com")
+})

tests/media.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { getMediaUrl } from "@/lib/media"
+
+test("returns empty string for missing media URL", () => {
+    assert.equal(getMediaUrl(null), "")
+    assert.equal(getMediaUrl(undefined), "")
+})
+
+test("keeps relative media URLs unchanged", () => {
+    assert.equal(getMediaUrl("/api/media/file/example.png"), "/api/media/file/example.png")
+})
+
+test("normalizes local Payload media URLs to relative paths", () => {
+    assert.equal(getMediaUrl("http://localhost:3000/api/media/file/example.png?size=small"), "/api/media/file/example.png?size=small")
+    assert.equal(getMediaUrl("http://127.0.0.1:3000/api/media/file/example.png"), "/api/media/file/example.png")
+})
+
+test("normalizes configured app media URLs to relative paths", () => {
+    const previousAppUrl = process.env.NEXT_PUBLIC_APP_URL
+    process.env.NEXT_PUBLIC_APP_URL = "https://codezero.build"
+
+    try {
+        assert.equal(getMediaUrl("https://codezero.build/api/media/file/example.png"), "/api/media/file/example.png")
+        assert.equal(getMediaUrl("https://cdn.example.com/api/media/file/example.png"), "https://cdn.example.com/api/media/file/example.png")
+    } finally {
+        process.env.NEXT_PUBLIC_APP_URL = previousAppUrl
+    }
+})

tests/smtp.test.ts

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { createRateLimitChecker, escapeHtml, getClientIdentifier, getRateLimitConfig } from "@/lib/smtp"
+
+test("escapes html-sensitive characters", () => {
+    assert.equal(escapeHtml(`<a href="x">It's ok & safe</a>`), "&lt;a href=&quot;x&quot;&gt;It&#039;s ok &amp; safe&lt;/a&gt;")
+})
+
+test("uses forwarded IP before real IP", () => {
+    const request = new Request("https://example.com", {
+        headers: {
+            "x-forwarded-for": "203.0.113.10, 203.0.113.11",
+            "x-real-ip": "198.51.100.1",
+        },
+    })
+
+    assert.equal(getClientIdentifier(request), "203.0.113.10")
+})
+
+test("falls back invalid rate limit env values", () => {
+    const previousMax = process.env.TEST_RATE_LIMIT_MAX
+    const previousWindow = process.env.TEST_RATE_LIMIT_WINDOW
+    process.env.TEST_RATE_LIMIT_MAX = "-1"
+    process.env.TEST_RATE_LIMIT_WINDOW = "nope"
+
+    try {
+        assert.deepEqual(getRateLimitConfig("TEST_RATE_LIMIT_MAX", "TEST_RATE_LIMIT_WINDOW", 3, 20), {
+            max: 3,
+            windowMs: 20_000,
+        })
+    } finally {
+        process.env.TEST_RATE_LIMIT_MAX = previousMax
+        process.env.TEST_RATE_LIMIT_WINDOW = previousWindow
+    }
+})
+
+test("blocks requests after configured max within window", () => {
+    const checkRateLimit = createRateLimitChecker({ max: 2, windowMs: 60_000 })
+
+    assert.deepEqual(checkRateLimit("client"), { allowed: true, retryAfterSeconds: 0 })
+    assert.deepEqual(checkRateLimit("client"), { allowed: true, retryAfterSeconds: 0 })
+
+    const blocked = checkRateLimit("client")
+    assert.equal(blocked.allowed, false)
+    assert.equal(blocked.retryAfterSeconds > 0, true)
+})

tests/subscriptionCalculator.test.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { calculateSubscriptionPrice, clampToRange, formatDiscountBadge, getPaymentPeriodDiscount, getPaymentPeriodSuffix } from "@/lib/subscriptionCalculator"
+
+const paymentPeriod = {
+    description: "Choose how often to pay.",
+    label: "Payment period",
+    monthlyPeriodSuffix: "per month",
+    monthlyText: "Monthly",
+    quarterlyDiscount: 0.1,
+    quarterlyPeriodSuffix: "per quarter",
+    quarterlyText: "Quarterly",
+    yearlyDiscount: 0.2,
+    yearlyPeriodSuffix: "per year",
+    yearlyText: "Yearly",
+}
+
+test("clamps usage values to configured range", () => {
+    const range = { min: 100, max: 1_000, step: 100 }
+
+    assert.equal(clampToRange(50, range), 100)
+    assert.equal(clampToRange(500, range), 500)
+    assert.equal(clampToRange(2_000, range), 1_000)
+})
+
+test("resolves payment period discounts and suffixes", () => {
+    assert.equal(getPaymentPeriodDiscount("monthly", paymentPeriod), 0)
+    assert.equal(getPaymentPeriodDiscount("quarterly", paymentPeriod), 0.1)
+    assert.equal(getPaymentPeriodDiscount("yearly", paymentPeriod), 0.2)
+
+    assert.equal(getPaymentPeriodSuffix("monthly", paymentPeriod), "per month")
+    assert.equal(getPaymentPeriodSuffix("quarterly", paymentPeriod), "per quarter")
+    assert.equal(getPaymentPeriodSuffix("yearly", paymentPeriod), "per year")
+})
+
+test("formats discount badges by locale", () => {
+    assert.equal(formatDiscountBadge(0.2, "en"), "20%")
+    assert.equal(formatDiscountBadge(0.2, "de"), "20\u00a0%")
+})
+
+test("calculates subscription totals before and after discount", () => {
+    assert.deepEqual(
+        calculateSubscriptionPrice({
+            additionalFeaturesPrice: 25,
+            aiTokenPriceFactor: 0.00001,
+            aiTokens: 1_000_000,
+            discount: 0.2,
+            workflowExecutionPriceFactor: 0.01,
+            workflowExecutions: 1_000,
+        }),
+        {
+            aiTokenPrice: 10,
+            totalBeforeDiscount: 45,
+            totalPrice: 36,
+            workflowExecutionPrice: 10,
+        }
+    )
+})