@omg-dev/billing 0.4.24

package/src/test/billing.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from "bun:test";
+import {
+  defineBilling,
+  addOn,
+  limit,
+  overage,
+  plan,
+  rateCard,
+  stripe,
+  polar,
+  usd,
+  money,
+  formatMoney,
+  MICROS_PER_UNIT,
+} from "../index.ts";
+import {
+  toCatalog,
+  serializeCatalog,
+  stableStringify,
+  planHash,
+  addOnHash,
+  fnv1a,
+} from "../catalog.ts";
+
+function fixture() {
+  return defineBilling({
+    provider: stripe(),
+    credit: { unit: "usd", peg: usd(1) },
+    features: {
+      llm_usage: { kind: "metered", label: "AI usage" },
+      published: { kind: "boolean" },
+    },
+    usage: {
+      llm_usage: rateCard({
+        "claude-opus-4-7": { in: usd(0.000015), out: usd(0.000075) },
+      }),
+    },
+    plans: {
+      free: plan({
+        price: usd(0),
+        default: true,
+        includes: { llm_usage: limit("$5"), published: false },
+      }),
+      pro: plan({
+        price: usd(20),
+        interval: "month",
+        includes: { llm_usage: limit("$25"), published: true },
+        usage: { llm_usage: overage() },
+      }),
+    },
+    addOns: {
+      seats: addOn({
+        price: usd(5),
+        interval: "month",
+        unit: "seat",
+        sizeMultipliers: { small: 1, large: 4 },
+      }),
+    },
+    grants: {
+      signup: { on: "customer.created", amount: usd(5), feature: "llm_usage" },
+    },
+  });
+}
+
+describe("money", () => {
+  it("converts dollars to integer micro-units", () => {
+    expect(usd(1)).toBe(MICROS_PER_UNIT);
+    expect(usd(5)).toBe(5_000_000);
+    expect(usd(0.000015)).toBe(15);
+  });
+
+  it("never carries a float at rest", () => {
+    expect(Number.isInteger(usd(0.000075))).toBe(true);
+  });
+
+  it("parses money strings", () => {
+    expect(money("$5")).toBe(5_000_000);
+    expect(money("0.25")).toBe(250_000);
+    expect(money(42 as never)).toBe(42);
+  });
+
+  it("rejects unparseable money", () => {
+    expect(() => money("abc")).toThrow();
+  });
+
+  it("formats back to a dollar string", () => {
+    expect(formatMoney(usd(5))).toBe("$5");
+    expect(formatMoney(usd(0.25))).toBe("$0.25");
+  });
+});
+
+describe("defineBilling validation", () => {
+  it("builds a normalized billing object", () => {
+    const b = fixture();
+    expect(b.plans.length).toBe(2);
+    expect(b.addOns.length).toBe(1);
+    expect(b.features.length).toBe(2);
+    expect(b.grants.length).toBe(1);
+  });
+
+  it("auto-labels features from their key", () => {
+    const b = fixture();
+    expect(b.features.find((f) => f.key === "published")?.label).toBe("Published");
+  });
+
+  it("requires exactly one default plan", () => {
+    expect(() =>
+      defineBilling({
+        provider: stripe(),
+        credit: { unit: "usd", peg: usd(1) },
+        features: { x: { kind: "boolean" } },
+        plans: { a: plan({ price: usd(0), includes: { x: true } }) },
+      }),
+    ).toThrow(/exactly one plan must be default/);
+  });
+
+  it("rejects a metered inclusion that is a boolean", () => {
+    expect(() =>
+      defineBilling({
+        provider: stripe(),
+        credit: { unit: "usd", peg: usd(1) },
+        features: { m: { kind: "metered" } },
+        plans: { a: plan({ price: usd(0), default: true, includes: { m: true } }) },
+      }),
+    ).toThrow(/is metered but got a boolean/);
+  });
+
+  it("rejects a rate card on an unknown feature", () => {
+    expect(() =>
+      defineBilling({
+        provider: polar(),
+        credit: { unit: "usd", peg: usd(1) },
+        features: { m: { kind: "metered" } },
+        usage: { ghost: rateCard({ x: { in: usd(1), out: usd(1) } }) },
+        plans: { a: plan({ price: usd(0), default: true, includes: { m: limit("$1") } }) },
+      }),
+    ).toThrow(/unknown feature/);
+  });
+
+  it("rejects a grant on a boolean feature", () => {
+    expect(() =>
+      defineBilling({
+        provider: stripe(),
+        credit: { unit: "usd", peg: usd(1) },
+        features: { b: { kind: "boolean" } },
+        plans: { a: plan({ price: usd(0), default: true, includes: { b: true } }) },
+        grants: { g: { on: "customer.created", amount: usd(5), feature: "b" } },
+      }),
+    ).toThrow(/grant on non-metered/);
+  });
+});
+
+describe("provider", () => {
+  it("never uses provider-side meters", () => {
+    expect(stripe().useProviderMeters).toBe(false);
+    expect(polar().useProviderMeters).toBe(false);
+  });
+});
+
+describe("catalog serialization", () => {
+  it("emits stable, sorted JSON regardless of key order", () => {
+    expect(stableStringify({ b: 1, a: 2 })).toBe('{"a":2,"b":1}');
+    expect(stableStringify({ a: 2, b: 1 })).toBe('{"a":2,"b":1}');
+  });
+
+  it("drops undefined fields", () => {
+    expect(stableStringify({ a: 1, b: undefined })).toBe('{"a":1}');
+  });
+
+  it("is deterministic across repeated serialization", () => {
+    const a = serializeCatalog(fixture());
+    const b = serializeCatalog(fixture());
+    expect(a).toBe(b);
+  });
+
+  it("includes a plan hash per plan", () => {
+    const cat = toCatalog(fixture());
+    for (const p of cat.plans) {
+      expect(p.hash).toMatch(/^[0-9a-f]{8}$/);
+    }
+  });
+
+  it("includes add-on hashes", () => {
+    const cat = toCatalog(fixture());
+    expect(cat.addOns).toHaveLength(1);
+    expect(cat.addOns[0].hash).toMatch(/^[0-9a-f]{8}$/);
+    expect(cat.addOns[0].priceHash).toMatch(/^[0-9a-f]{8}$/);
+  });
+
+  it("plan hash excludes cosmetic copy (label/description)", () => {
+    const base = fixture();
+    const free1 = base.plans.find((p) => p.key === "free")!;
+    const relabeled = { ...free1, label: "Totally Different", description: "x" };
+    expect(planHash(relabeled)).toBe(planHash(free1));
+  });
+
+  it("plan hash changes when price changes", () => {
+    const base = fixture();
+    const free = base.plans.find((p) => p.key === "free")!;
+    const pricier = { ...free, price: usd(9) as typeof free.price };
+    expect(planHash(pricier)).not.toBe(planHash(free));
+  });
+
+  it("plan hash changes when an allowance changes", () => {
+    const base = fixture();
+    const free = base.plans.find((p) => p.key === "free")!;
+    const bumped = {
+      ...free,
+      inclusions: free.inclusions.map((i) =>
+        i.kind === "metered" ? { ...i, allowance: usd(50) as typeof i.allowance } : i,
+      ),
+    };
+    expect(planHash(bumped)).not.toBe(planHash(free));
+  });
+
+  it("fnv1a is stable", () => {
+    expect(fnv1a("")).toBe("811c9dc5");
+    expect(fnv1a("hello")).toBe(fnv1a("hello"));
+  });
+
+  it("add-on hash changes when provider-relevant price changes", () => {
+    const base = fixture().addOns[0];
+    const pricier = { ...base, price: usd(9) as typeof base.price };
+    expect(addOnHash(pricier)).not.toBe(addOnHash(base));
+  });
+});