Sign in

pulls/pr_01m47d15m3e54sn21z27rpy5n9

public

pr_01m47d15m3e54sn21z27rpy5n9/apps/web/app/lib/billing.test.ts

203 lines10,710 bytesCodeBlame

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

Invite-only launch: sign in with GitHub, repository access and lifecycle, many emails, a new look1import assert from "node:assert/strict";
2import { test } from "node:test";
3
4import {
5 alertText,
6 alertTone,
7 cardCheckResult,
8 dollars,
9 needsAttention,
10 usageGlance,
11 parseCaps,
12 parseLimitRequest,
13 parsePrepay,
14 parseSpendLimit,
15 planStatus,
16 readDollars,
17 requestStatus,
18 share,
19 spendPath,
20 spendRange,
21 wholeDollars,
22} from "./billing.ts";
23
24test("money reads as dollars", () => {
25 assert.equal(dollars(9_500_000), "$9.50");
26 assert.equal(dollars(-1_250_000), "−$1.25");
27 assert.equal(wholeDollars(1_000_000_000), "$1,000");
28 assert.equal(wholeDollars(100_000), "$0.10");
29 assert.equal(readDollars("$1,000"), 1_000_000_000);
30 assert.equal(readDollars(""), null);
31 assert.equal(readDollars("lots"), null);
32});
33
34test("a prepayment is $25 or more, by card up to $10,000, by bank transfer from $1,000", () => {
35 assert.deepEqual(parsePrepay({ amount: "100" }), { ok: true, value: { amountCents: 10_000, method: "card" } });
36 assert.deepEqual(parsePrepay({ amount: "100", custom: "250" }), {
37 ok: true,
38 value: { amountCents: 25_000, method: "card" },
39 });
40 assert.equal(parsePrepay({ custom: "10" }).ok, false);
41 assert.equal(parsePrepay({ custom: "20000" }).ok, false);
42 assert.equal(parsePrepay({ custom: "500", method: "bank_transfer" }).ok, false);
43 assert.deepEqual(parsePrepay({ custom: "20000", method: "bank_transfer" }), {
44 ok: true,
45 value: { amountCents: 2_000_000, method: "bank_transfer" },
46 });
47 assert.equal(parsePrepay({}).ok, false);
48});
49
50test("caps stay in range, and empty goes back to the default", () => {
51 assert.deepEqual(parseCaps({ run: "", issue: "" }), { ok: true, value: { runCapMicros: null, issueCapMicros: null } });
52 assert.deepEqual(parseCaps({ run: "0.10", issue: "1000" }), {
53 ok: true,
54 value: { runCapMicros: 100_000, issueCapMicros: 1_000_000_000 },
55 });
56 assert.equal(parseCaps({ run: "0.05" }).ok, false);
57 assert.equal(parseCaps({ issue: "2000" }).ok, false);
58 assert.equal(parseCaps({ run: "two" }).ok, false);
59});
60
61test("a limit request needs an amount, a reason and a monthly spend; an overage only a reason", () => {
62 assert.deepEqual(parseLimitRequest({ kind: "limit", amount: "5000", reason: " A launch ", expected: "3000" }), {
63 ok: true,
64 value: { kind: "limit", amountMicros: 5_000_000_000, reason: "A launch", expectedMonthlyMicros: 3_000_000_000 },
65 });
66 assert.equal(parseLimitRequest({ kind: "limit", amount: "5000", reason: "" , expected: "1" }).ok, false);
67 assert.equal(parseLimitRequest({ kind: "limit", reason: "x", expected: "1" }).ok, false);
68 assert.deepEqual(parseLimitRequest({ kind: "overage", reason: "A loop ran all night" }), {
69 ok: true,
70 value: { kind: "overage", amountMicros: 0, reason: "A loop ran all night", expectedMonthlyMicros: 0 },
71 });
72});
73
74test("a spend limit is automatic, fixed, the full amount available, or the one-time raise", () => {
75 assert.deepEqual(parseSpendLimit({ mode: "automatic" }), { ok: true, value: { micros: null, useFull: false, raiseOnce: false } });
76 assert.deepEqual(parseSpendLimit({ mode: "fixed", limit: "500" }), {
77 ok: true,
78 value: { micros: 500_000_000, useFull: false, raiseOnce: false },
79 });
80 assert.equal(parseSpendLimit({ mode: "fixed", limit: "0.5" }).ok, false);
81 assert.deepEqual(parseSpendLimit({ mode: "full" }), { ok: true, value: { micros: null, useFull: true, raiseOnce: false } });
82 assert.deepEqual(parseSpendLimit({ mode: "raise" }), { ok: true, value: { micros: null, useFull: false, raiseOnce: true } });
83 assert.deepEqual(parseSpendLimit({ mode: "raise", limit: "150" }), {
84 ok: true,
85 value: { micros: 150_000_000, useFull: false, raiseOnce: true },
86 });
87});
88
89test("the spend limit's range: up to the highest ceiling plus prepaid, then once to twice it, then ask", () => {
90 // A first month at $100, nothing prepaid, the raise unused: $100 alone, $200 once.
91 const range = spendRange({ availableMicros: 100_000_000, ceilingMicros: 100_000_000, raiseOnceMicros: 200_000_000, raisedAt: null });
92 assert.deepEqual(range, { selfServeMicros: 100_000_000, raiseOnceMicros: 200_000_000, raisedAt: null });
93 assert.equal(spendPath(80_000_000, range), "self");
94 assert.equal(spendPath(100_000_000, range), "self");
95 assert.equal(spendPath(150_000_000, range), "raise");
96 assert.equal(spendPath(200_000_000, range), "raise");
97 assert.equal(spendPath(200_000_001, range), "ask");
98 // The raise used: only asking goes further.
99 const used = spendRange({ availableMicros: 200_000_000, ceilingMicros: 200_000_000, raiseOnceMicros: null, raisedAt: "2026-10-01T00:00:00Z" });
100 assert.equal(used.raiseOnceMicros, null);
101 assert.equal(spendPath(300_000_000, used), "ask");
102 // No ceiling: anything goes.
103 assert.equal(spendPath(1e12, spendRange({ availableMicros: null, ceilingMicros: null, raiseOnceMicros: null })), "self");
104 // A raise no higher than what is available is no raise.
105 assert.equal(spendRange({ availableMicros: 300_000_000, ceilingMicros: 100_000_000, raiseOnceMicros: 300_000_000 }).raiseOnceMicros, null);
106});
107
108test("the plan card says where the workspace stands", () => {
109 const free = { plan: "free" as const, trialMicrosLeft: 0, trialVerified: false, firstMonth: false };
110 assert.deepEqual(planStatus(null, free), { kind: "free", label: "Free" });
111 assert.equal(planStatus(null, { ...free, trialVerified: true, trialMicrosLeft: 5_000_000 }).kind, "trial");
112 assert.equal(planStatus(null, { ...free, trialVerified: true }).kind, "free");
113 const subscription = { feature: "plan" as const, status: "active" as const, periodEnd: null, startedBy: "a", startedAt: "" };
114 assert.deepEqual(planStatus({ on: true, subscription }, { ...free, plan: "paid", firstMonth: true }), {
115 kind: "paid",
116 label: "On the g1t plan, first month",
117 });
118 assert.equal(planStatus({ on: true, subscription: { ...subscription, status: "canceling" } }, { ...free, plan: "paid" }).kind, "canceling");
119 assert.equal(planStatus({ on: false, subscription: { ...subscription, status: "past_due" } }, free).kind, "past_due");
120 assert.equal(planStatus({ on: true, included: true, subscription: null }, free).kind, "comped");
121 assert.equal(planStatus(null, { ...free, plan: "internal" }).kind, "comped");
122 assert.equal(planStatus(null, { ...free, plan: "enterprise" }).kind, "enterprise");
123});
124
125test("the overview's Usage card reads the month by what pays", () => {
126 const usage = {
127 free: false,
128 spentMicros: 14_000_000,
129 usedMicros: 11_000_000,
130 byTask: [
131 { key: "review", micros: 2_000_000, runs: 4 },
132 { key: "implement", micros: 12_000_000, runs: 9 },
133 { key: "plan", micros: 0, runs: 1 },
134 ],
135 };
136 const entitlements = { includedMicros: 10_000_000, includedUsedMicros: 10_000_000, trialMicrosLeft: 0 };
137 const plan = usageGlance({ usage, status: { kind: "paid", label: "" }, entitlements, limit: { spentMicros: 4_000_000, spendLimitMicros: 200_000_000 }, trialMicros: 5_000_000 });
138 assert.equal(plan.kind, "plan");
139 assert.deepEqual(plan.credit, { label: "Included usage", usedMicros: 10_000_000, ofMicros: 10_000_000 });
140 assert.deepEqual(plan.onDemand, { micros: 4_000_000, limitMicros: 200_000_000 });
141 // Most first, and nothing that cost nothing.
142 assert.deepEqual(plan.lines.map((line) => line.label), ["Making changes", "Reviews"]);
143 const trial = usageGlance({ usage, status: { kind: "trial", label: "" }, entitlements: { ...entitlements, trialMicrosLeft: 1_500_000 }, limit: null, trialMicros: 5_000_000 });
144 assert.deepEqual(trial.credit, { label: "Trial credit", usedMicros: 3_500_000, ofMicros: 5_000_000 });
145 assert.equal(trial.onDemand, null);
146 assert.equal(usageGlance({ usage, status: { kind: "comped", label: "" }, entitlements, limit: null, trialMicros: 0 }).kind, "comped");
147 assert.equal(usageGlance({ usage, status: { kind: "free", label: "" }, entitlements, limit: null, trialMicros: 0 }).kind, "forge");
148 // While g1t charges nothing, usage is shown at cost.
149 const beta = usageGlance({ usage: { ...usage, free: true }, status: { kind: "paid", label: "" }, entitlements, limit: null, trialMicros: 0 });
150 assert.equal(beta.kind, "beta");
151 assert.equal(beta.spentMicros, 11_000_000);
152});
153
154test("a meter's share stays between 0 and 1", () => {
155 assert.equal(share(5, 10), 0.5);
156 assert.equal(share(15, 10), 1);
157 assert.equal(share(5, 0), 0);
158 assert.equal(share(5, null), 0);
159});
160
161test("after a card check the owner reads whether the trial started", () => {
162 assert.match(cardCheckResult({ trialVerified: true, trialMicrosLeft: 5_000_000 }, 5_000_000), /[$]5 trial is ready/);
163 assert.match(cardCheckResult({ trialVerified: true, trialMicrosLeft: 0 }, 5_000_000), /Prepaid cards can still pay for the plan/);
164 assert.match(cardCheckResult({ trialVerified: false, trialMicrosLeft: 0 }, 5_000_000), /did not finish/);
165});
166
167test("alerts read as sentences", () => {
168 const alert = { meter: "included", level: 90, usedMicros: 9_000_000, limitMicros: 10_000_000, message: "" };
169 assert.equal(alertText(alert), "90% of the plan's included usage: $9.00 of $10.00.");
170 assert.equal(alertText({ ...alert, meter: "spend_limit", level: 100 }), "All of your spend limit: $9.00 of $10.00.");
171 assert.equal(alertTone(50), "ok");
172 assert.equal(alertTone(75), "warning");
173 assert.equal(alertTone(100), "stopped");
174});
175
176test("a workspace needs attention when paused, on a spike, or at 90%", () => {
177 assert.equal(needsAttention(null), false);
178 assert.equal(needsAttention({ paused: null, spike: null, alerts: [] }), false);
179 assert.equal(needsAttention({ paused: "Spend spike", spike: null, alerts: [] }), true);
180 const spike = { id: "s", status: "continued", hourMicros: 1, averageMicros: 1, detectedAt: "" };
181 assert.equal(needsAttention({ paused: null, spike, alerts: [] }), false);
182 assert.equal(needsAttention({ paused: null, spike: { ...spike, status: "open" }, alerts: [] }), true);
183 const at = (level: number) => ({ meter: "spend_limit", level, usedMicros: 0, limitMicros: 0, message: "" });
184 assert.equal(needsAttention({ paused: null, spike: null, alerts: [at(75)] }), false);
185 assert.equal(needsAttention({ paused: null, spike: null, alerts: [at(90)] }), true);
186});
187
188test("a request says where it stands", () => {
189 const request = {
190 id: "r",
191 workspace: "acme",
192 kind: "limit",
193 amountMicros: 1,
194 reason: "",
195 expectedMonthlyMicros: 0,
196 status: "open",
197 createdBy: "a",
198 createdAt: "",
199 };
200 assert.equal(requestStatus(request), "Waiting for an answer");
201 assert.equal(requestStatus({ ...request, status: "approved", decidedMicros: 2_000_000_000 }), "Approved at $2,000");
202 assert.equal(requestStatus({ ...request, status: "declined" }), "Declined");
203});