@simplelayer/graniteer-core 0.0.1 → 0.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/index.js +2 -2
- package/package.json +98 -15
- package/src/adminBookingCredit.test.ts +451 -0
- package/src/adminBookingCredit.ts +239 -0
- package/src/availability.test.ts +25 -0
- package/src/availability.ts +201 -0
- package/src/bookingHoldReclaim.ts +94 -0
- package/src/checkoutSessionParams.ts +56 -0
- package/src/commonsContract.ts +175 -0
- package/src/conductorAdmin.ts +141 -0
- package/src/email-templates/email-change.tsx +92 -0
- package/src/email-templates/invite.tsx +79 -0
- package/src/email-templates/reauthentication.tsx +60 -0
- package/src/functions/admin-cancel-membership.ts +311 -0
- package/src/functions/admin-change-membership-plan.ts +308 -0
- package/src/functions/admin-charge-guest-print.ts +229 -0
- package/src/functions/admin-correct-booking.ts +333 -0
- package/src/functions/admin-create-commons-event.ts +244 -0
- package/src/functions/admin-debug-boldsign-doc.ts +93 -0
- package/src/functions/admin-door-write.ts +272 -0
- package/src/functions/admin-mark-booking-paid.ts +203 -0
- package/src/functions/admin-photo-upload.ts +128 -0
- package/src/functions/admin-remove-team-member.ts +150 -0
- package/src/functions/admin-reset-mfa.ts +138 -0
- package/src/functions/admin-reverse-coupon-redemption.ts +98 -0
- package/src/functions/admin-send-commons-agreement.ts +214 -0
- package/src/functions/admin-set-credit-amount.ts +123 -0
- package/src/functions/admin-skip-commons-contract.ts +165 -0
- package/src/functions/admin-undo-membership-cancel.ts +144 -0
- package/src/functions/admin-wall-photo-write.ts +141 -0
- package/src/functions/boldsign-sender-identity.ts +114 -0
- package/src/functions/booking-availability.ts +419 -0
- package/src/functions/booking-member-preview.ts +136 -0
- package/src/functions/day-pass-status.ts +89 -0
- package/src/functions/dayStatus.ts +71 -0
- package/src/functions/diag-webpush-test.ts +45 -0
- package/src/functions/event-access-store.ts +309 -0
- package/src/functions/ezeep-print-webhook.ts +213 -0
- package/src/functions/ezeep-usage-reconcile.ts +299 -0
- package/src/functions/get-signing-link.ts +211 -0
- package/src/functions/guest-print-setup-confirm.ts +128 -0
- package/src/functions/guest-print-submit.ts +149 -0
- package/src/functions/luma-webhook.ts +165 -0
- package/src/functions/migration-collision-alert.copy.ts +232 -0
- package/src/functions/migration-collision-alert.test.ts +349 -0
- package/src/functions/migration-collision-alert.ts +232 -0
- package/src/functions/office-assignment-end.ts +146 -0
- package/src/functions/portal-booking-access.ts +95 -0
- package/src/functions/portal-list-invoices.ts +99 -0
- package/src/functions/print-billing-recover.ts +97 -0
- package/src/functions/print-billing-run.ts +183 -0
- package/src/functions/public-facts.ts +168 -0
- package/src/functions/space-availability-range.acceptance.test.ts +161 -0
- package/src/functions/space-availability-range.ts +142 -0
- package/src/functions/sync-gcal-blackouts.ts +298 -0
- package/src/functions/timetable-event-register.ts +162 -0
- package/src/functions/timetable-event-status.ts +90 -0
- package/src/functions/timetable-spaces.ts +219 -0
- package/src/functions/touch-pass-reconciler.ts +689 -0
- package/src/functions/virtual-onboarding-purge.ts +134 -0
- package/src/functions/virtual-onboarding-submit.ts +315 -0
- package/src/functions/voice-inquiry.test.ts +301 -0
- package/src/functions/voice-inquiry.ts +198 -0
- package/src/functions/voice-tour-availability.ts +204 -0
- package/src/gcalSync.ts +142 -0
- package/src/ghlNote.ts +34 -0
- package/src/ghlTask.ts +48 -0
- package/src/ghlVoiceInquiry.ts +90 -0
- package/src/guestPrintCapture.test.ts +722 -0
- package/src/guestPrintCapture.ts +538 -0
- package/src/lumaGhl.ts +195 -0
- package/src/membership.ts +109 -0
- package/src/money.ts +36 -0
- package/src/ops.ts +97 -0
- package/src/pacificDate.ts +34 -0
- package/src/policyAcknowledgment.test.ts +50 -0
- package/src/policyAcknowledgment.ts +96 -0
- package/src/portalSession.ts +46 -0
- package/src/pricing.test.ts +660 -0
- package/src/pricing.ts +1025 -0
- package/src/printBilling.test.ts +750 -0
- package/src/printBilling.ts +891 -0
- package/src/printBillingAdapters.ts +169 -0
- package/src/printCorrections.test.ts +348 -0
- package/src/printCorrections.ts +496 -0
- package/src/rateLimit.ts +82 -0
- package/src/referralCredits.test.ts +31 -0
- package/src/referralCredits.ts +34 -0
- package/src/referralGrant.ts +321 -0
- package/src/rescheduleCredit.test.ts +521 -0
- package/src/rescheduleCredit.ts +337 -0
- package/src/reservationWifiCode.test.ts +69 -0
- package/src/reservationWifiCode.ts +81 -0
- package/src/retellCallAnalyzed.test.ts +167 -0
- package/src/retellCallAnalyzed.ts +113 -0
- package/src/retellSignature.test.ts +137 -0
- package/src/retellSignature.ts +82 -0
- package/src/slackAlert.ts +38 -0
- package/src/supabaseTestFakes.ts +131 -0
- package/src/tier1Agreement.ts +125 -0
|
@@ -0,0 +1,750 @@
|
|
|
1
|
+
// Tests for the print-usage-bill P2 decision core.
|
|
2
|
+
//
|
|
3
|
+
// Run with:
|
|
4
|
+
// deno test --no-check --no-lock --allow-read \
|
|
5
|
+
// supabase/functions/_shared/printBilling.test.ts
|
|
6
|
+
//
|
|
7
|
+
// ZERO NETWORK, AND IN PARTICULAR ZERO LIVE STRIPE. globalThis.fetch is replaced
|
|
8
|
+
// with a throwing stub before anything else runs, so any accidental outbound call
|
|
9
|
+
// fails loudly instead of reaching api.stripe.com with live keys. The Stripe
|
|
10
|
+
// client is a hand-rolled object with call counters; the database is an in-memory
|
|
11
|
+
// fake. section 8.5's live half is GATED and nothing here can reach it.
|
|
12
|
+
//
|
|
13
|
+
// Covers: section 4.2's anomaly/cap gate (T-46c..T-46f), section 4.3's oracle including
|
|
14
|
+
// the 404 rule (round 8 blocking finding 3), section 4.4's state-transition table
|
|
15
|
+
// (T-50..T-58b), and the two dedup/claim invariants the money path depends on
|
|
16
|
+
// (T-26h, T-118d/f).
|
|
17
|
+
|
|
18
|
+
import { assert, assertEquals } from 'https://deno.land/std@0.224.0/assert/mod.ts';
|
|
19
|
+
import {
|
|
20
|
+
ANOMALY_MULTIPLIER,
|
|
21
|
+
BASELINE_SQL,
|
|
22
|
+
decideRecoveryAction,
|
|
23
|
+
ELIGIBILITY_SQL,
|
|
24
|
+
evaluateGate,
|
|
25
|
+
executeBillingRun,
|
|
26
|
+
finalizeKey,
|
|
27
|
+
HARD_CAP_CENTS,
|
|
28
|
+
itemKey,
|
|
29
|
+
postItemsAndFinalize,
|
|
30
|
+
resolveDefaultPaymentMethod,
|
|
31
|
+
runKey,
|
|
32
|
+
runOracle,
|
|
33
|
+
runRecoverySweep,
|
|
34
|
+
STRIPE_MIN_CENTS,
|
|
35
|
+
type PeriodRow,
|
|
36
|
+
type PrintDbLike,
|
|
37
|
+
type PrintStripeLike,
|
|
38
|
+
type RunInput,
|
|
39
|
+
type RunRow,
|
|
40
|
+
type StripeCustomer,
|
|
41
|
+
type StripeInvoice,
|
|
42
|
+
type StripeSubscription,
|
|
43
|
+
} from './printBilling.ts';
|
|
44
|
+
|
|
45
|
+
// Any real outbound request from this point on is a test failure, not a silent
|
|
46
|
+
// live-Stripe call.
|
|
47
|
+
const NETWORK_ATTEMPTS: string[] = [];
|
|
48
|
+
globalThis.fetch = ((input: string | URL | Request) => {
|
|
49
|
+
const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
|
|
50
|
+
NETWORK_ATTEMPTS.push(url);
|
|
51
|
+
throw new Error(`BLOCKED: test attempted a real network call to ${url}`);
|
|
52
|
+
}) as typeof fetch;
|
|
53
|
+
|
|
54
|
+
const RUN = '11111111-1111-1111-1111-111111111111';
|
|
55
|
+
const MEMBERSHIP = '22222222-2222-2222-2222-222222222222';
|
|
56
|
+
const P1 = 'aaaaaaaa-0000-0000-0000-000000000001';
|
|
57
|
+
const P2 = 'aaaaaaaa-0000-0000-0000-000000000002';
|
|
58
|
+
const CUST = 'cus_test';
|
|
59
|
+
const ACCT = 'acct_expected';
|
|
60
|
+
|
|
61
|
+
// --------------------------------------------------------------- the fakes --
|
|
62
|
+
|
|
63
|
+
interface StripeCalls {
|
|
64
|
+
create: Record<string, unknown>[];
|
|
65
|
+
items: Record<string, unknown>[];
|
|
66
|
+
finalize: string[];
|
|
67
|
+
retrieve: string[];
|
|
68
|
+
list: number;
|
|
69
|
+
idem: string[];
|
|
70
|
+
subRetrieve: string[];
|
|
71
|
+
custRetrieve: string[];
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
function mkStripe(opts: {
|
|
75
|
+
invoiceStatus?: string;
|
|
76
|
+
retrieveThrows?: 'notfound' | 'transient' | null;
|
|
77
|
+
listReturns?: StripeInvoice[];
|
|
78
|
+
createThrows?: boolean;
|
|
79
|
+
finalizeThrows?: boolean;
|
|
80
|
+
itemThrows?: boolean;
|
|
81
|
+
accountId?: string;
|
|
82
|
+
livemode?: boolean;
|
|
83
|
+
// T-81 / C-13 fixtures — see resolveDefaultPaymentMethod tests below.
|
|
84
|
+
subscription?: StripeSubscription | null;
|
|
85
|
+
subscriptionThrows?: boolean;
|
|
86
|
+
customer?: StripeCustomer | null;
|
|
87
|
+
customerThrows?: boolean;
|
|
88
|
+
} = {}): { stripe: PrintStripeLike; calls: StripeCalls } {
|
|
89
|
+
const calls: StripeCalls = {
|
|
90
|
+
create: [], items: [], finalize: [], retrieve: [], list: 0, idem: [],
|
|
91
|
+
subRetrieve: [], custRetrieve: [],
|
|
92
|
+
};
|
|
93
|
+
let seq = 0;
|
|
94
|
+
const stripe: PrintStripeLike = {
|
|
95
|
+
account: {
|
|
96
|
+
retrieve: () => Promise.resolve({ id: opts.accountId ?? ACCT, livemode: opts.livemode ?? false }),
|
|
97
|
+
},
|
|
98
|
+
invoices: {
|
|
99
|
+
create: (params, o) => {
|
|
100
|
+
calls.create.push(params);
|
|
101
|
+
if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
|
|
102
|
+
if (opts.createThrows) return Promise.reject(new Error('stripe down'));
|
|
103
|
+
return Promise.resolve({ id: 'in_created', status: 'draft', metadata: { gc_run_id: RUN } });
|
|
104
|
+
},
|
|
105
|
+
retrieve: (id) => {
|
|
106
|
+
calls.retrieve.push(id);
|
|
107
|
+
if (opts.retrieveThrows === 'notfound') {
|
|
108
|
+
return Promise.reject(Object.assign(new Error('No such invoice'), { statusCode: 404 }));
|
|
109
|
+
}
|
|
110
|
+
if (opts.retrieveThrows === 'transient') {
|
|
111
|
+
return Promise.reject(Object.assign(new Error('gateway'), { statusCode: 500 }));
|
|
112
|
+
}
|
|
113
|
+
return Promise.resolve({ id, status: opts.invoiceStatus ?? 'draft', metadata: { gc_run_id: RUN } });
|
|
114
|
+
},
|
|
115
|
+
list: () => {
|
|
116
|
+
calls.list++;
|
|
117
|
+
return Promise.resolve({ data: opts.listReturns ?? [], has_more: false });
|
|
118
|
+
},
|
|
119
|
+
finalize: (id, _p, o) => {
|
|
120
|
+
calls.finalize.push(id);
|
|
121
|
+
if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
|
|
122
|
+
if (opts.finalizeThrows) return Promise.reject(new Error('finalize failed'));
|
|
123
|
+
return Promise.resolve({ id, status: 'open', metadata: { gc_run_id: RUN } });
|
|
124
|
+
},
|
|
125
|
+
listLines: (_id) => Promise.resolve({
|
|
126
|
+
data: [
|
|
127
|
+
{ id: 'il_1', parent: { invoice_item_details: { invoice_item: 'ii_1' } } },
|
|
128
|
+
{ id: 'il_2', parent: { invoice_item_details: { invoice_item: 'ii_2' } } },
|
|
129
|
+
],
|
|
130
|
+
}),
|
|
131
|
+
},
|
|
132
|
+
invoiceItems: {
|
|
133
|
+
create: (params, o) => {
|
|
134
|
+
calls.items.push(params);
|
|
135
|
+
if (o?.idempotencyKey) calls.idem.push(o.idempotencyKey);
|
|
136
|
+
if (opts.itemThrows) return Promise.reject(new Error('item failed'));
|
|
137
|
+
seq++;
|
|
138
|
+
return Promise.resolve({ id: `ii_${seq}` });
|
|
139
|
+
},
|
|
140
|
+
},
|
|
141
|
+
subscriptions: {
|
|
142
|
+
retrieve: (id) => {
|
|
143
|
+
calls.subRetrieve.push(id);
|
|
144
|
+
if (opts.subscriptionThrows) return Promise.reject(new Error('no such subscription'));
|
|
145
|
+
return Promise.resolve(opts.subscription ?? { id, default_payment_method: null });
|
|
146
|
+
},
|
|
147
|
+
},
|
|
148
|
+
customers: {
|
|
149
|
+
retrieve: (id) => {
|
|
150
|
+
calls.custRetrieve.push(id);
|
|
151
|
+
if (opts.customerThrows) return Promise.reject(new Error('no such customer'));
|
|
152
|
+
return Promise.resolve(opts.customer ?? { id, invoice_settings: { default_payment_method: null } });
|
|
153
|
+
},
|
|
154
|
+
},
|
|
155
|
+
};
|
|
156
|
+
return { stripe, calls };
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
interface DbState {
|
|
160
|
+
periods: Record<string, PeriodRow>;
|
|
161
|
+
writebacks: { status: string; invoiceId: string | null; detail: Record<string, unknown> }[];
|
|
162
|
+
holds: string[];
|
|
163
|
+
releases: number;
|
|
164
|
+
ops: { kind: string; severity: string }[];
|
|
165
|
+
claimThrows?: string;
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
function mkDb(state: Partial<DbState> = {}): { db: PrintDbLike; st: DbState } {
|
|
169
|
+
const st: DbState = {
|
|
170
|
+
periods: state.periods ?? {
|
|
171
|
+
[P1]: {
|
|
172
|
+
id: P1, charge_cents_total: 600, bw_billable: 60, color_pages: 0,
|
|
173
|
+
period_month: '2026-07-01', billing_run_id: RUN, billed_run_id: RUN,
|
|
174
|
+
stripe_invoice_item_id: null, stripe_invoice_id: null,
|
|
175
|
+
},
|
|
176
|
+
[P2]: {
|
|
177
|
+
id: P2, charge_cents_total: 400, bw_billable: 40, color_pages: 0,
|
|
178
|
+
period_month: '2026-08-01', billing_run_id: RUN, billed_run_id: RUN,
|
|
179
|
+
stripe_invoice_item_id: null, stripe_invoice_id: null,
|
|
180
|
+
},
|
|
181
|
+
},
|
|
182
|
+
writebacks: [], holds: [], releases: 0, ops: [],
|
|
183
|
+
claimThrows: state.claimThrows,
|
|
184
|
+
};
|
|
185
|
+
|
|
186
|
+
const db: PrintDbLike = {
|
|
187
|
+
claim: () => {
|
|
188
|
+
if (st.claimThrows) {
|
|
189
|
+
return Promise.reject(Object.assign(new Error('claim refused'), { gcCode: st.claimThrows }));
|
|
190
|
+
}
|
|
191
|
+
return Promise.resolve({ run_id: RUN, lease_token: 'lease-1', lease_expires_at: 'later' });
|
|
192
|
+
},
|
|
193
|
+
attemptBump: () => Promise.resolve(1),
|
|
194
|
+
leaseRenew: () => Promise.resolve('later'),
|
|
195
|
+
leaseAcquire: (runId) => Promise.resolve({ lease_token: `lease-${runId}`, lease_expires_at: 'later' }),
|
|
196
|
+
writeback: (_r, _l, status, invoiceId, detail) => {
|
|
197
|
+
st.writebacks.push({ status, invoiceId, detail });
|
|
198
|
+
// mirror M-14: stamp the item id onto the period so 3.1's oracle works
|
|
199
|
+
for (const [pid, v] of Object.entries(detail ?? {})) {
|
|
200
|
+
const item = (v as { item_id?: string }).item_id;
|
|
201
|
+
if (item && st.periods[pid]) st.periods[pid].stripe_invoice_item_id = item;
|
|
202
|
+
}
|
|
203
|
+
// and B10-1's unconditional invoice-id stamp on every claimed period
|
|
204
|
+
if (invoiceId) {
|
|
205
|
+
for (const p of Object.values(st.periods)) {
|
|
206
|
+
if (p.billed_run_id === RUN && !p.stripe_invoice_id) p.stripe_invoice_id = invoiceId;
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
return Promise.resolve();
|
|
210
|
+
},
|
|
211
|
+
hold: (_r, _l, reason) => { st.holds.push(reason); return Promise.resolve(); },
|
|
212
|
+
releaseRun: () => { st.releases++; return Promise.resolve(); },
|
|
213
|
+
paymentStatus: () => Promise.resolve(),
|
|
214
|
+
getPeriod: (id) => Promise.resolve(st.periods[id] ?? null),
|
|
215
|
+
baseline: () => Promise.resolve({ baseline_cents: 0, qualifying_periods: 0 }),
|
|
216
|
+
recoverySelect: () => Promise.resolve([]),
|
|
217
|
+
opsEvent: (kind, severity) => { st.ops.push({ kind, severity }); return Promise.resolve(); },
|
|
218
|
+
};
|
|
219
|
+
return { db, st };
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
const INPUT: RunInput = {
|
|
223
|
+
runId: RUN, membershipId: MEMBERSHIP, customerId: CUST,
|
|
224
|
+
periodIds: [P1, P2], periodMonths: ['2026-07-01', '2026-08-01'],
|
|
225
|
+
amountCents: 1000, defaultPaymentMethod: 'pm_1',
|
|
226
|
+
expectedAccountId: ACCT, expectedLivemode: false,
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
// ============================================================ section 4.2 gate ==
|
|
230
|
+
|
|
231
|
+
Deno.test("T-46c [R-08] the $75.00 cap boundary is strictly greater-than", () => {
|
|
232
|
+
assertEquals(evaluateGate({ amountCents: 7499, baselineCents: 0, qualifyingPeriods: 0 }).overCap, false);
|
|
233
|
+
assertEquals(evaluateGate({ amountCents: 7500, baselineCents: 0, qualifyingPeriods: 0 }).overCap, false);
|
|
234
|
+
assertEquals(evaluateGate({ amountCents: 7501, baselineCents: 0, qualifyingPeriods: 0 }).overCap, true);
|
|
235
|
+
assertEquals(HARD_CAP_CENTS, 7500);
|
|
236
|
+
});
|
|
237
|
+
|
|
238
|
+
Deno.test("T-46d [R-08] the 10x ratio boundary is >= , matching ' 10x or more'", () => {
|
|
239
|
+
const g = (a: number) => evaluateGate({ amountCents: a, baselineCents: 100, qualifyingPeriods: 6 }).anomaly;
|
|
240
|
+
assertEquals(g(999), false);
|
|
241
|
+
assertEquals(g(1000), true);
|
|
242
|
+
assertEquals(g(1001), true);
|
|
243
|
+
assertEquals(ANOMALY_MULTIPLIER, 10);
|
|
244
|
+
});
|
|
245
|
+
|
|
246
|
+
Deno.test("T-46e [R-08] a thin history SKIPS the relative check entirely", () => {
|
|
247
|
+
// Same 10x overage, but only 2 qualifying periods: R2's finding — a member's
|
|
248
|
+
// first real charge must not trip a ratio against a thin history.
|
|
249
|
+
const r = evaluateGate({ amountCents: 5000, baselineCents: 100, qualifyingPeriods: 2 });
|
|
250
|
+
assertEquals(r.anomaly, false);
|
|
251
|
+
assertEquals(r.overCap, false);
|
|
252
|
+
assertEquals(r.blocked, false);
|
|
253
|
+
});
|
|
254
|
+
|
|
255
|
+
Deno.test("T-46f [R-08] both gates fire at once; neither short-circuits", () => {
|
|
256
|
+
const r = evaluateGate({ amountCents: 9000, baselineCents: 100, qualifyingPeriods: 6 });
|
|
257
|
+
assertEquals(r.overCap, true);
|
|
258
|
+
assertEquals(r.anomaly, true);
|
|
259
|
+
});
|
|
260
|
+
|
|
261
|
+
Deno.test("T-46 [B12-1] the baseline query windows in a SUBQUERY, and returns both operands", () => {
|
|
262
|
+
// The v6..v17 form put ORDER BY beside an ungrouped avg(), which PostgreSQL
|
|
263
|
+
// rejects with 42803, and deleting the ORDER BY silently widened the window to
|
|
264
|
+
// the membership's whole history. Assert the shape that fixes both.
|
|
265
|
+
assert(BASELINE_SQL.includes('qualifying_periods'), 'rule 2 needs the count operand');
|
|
266
|
+
assert(/from \(/s.test(BASELINE_SQL), 'the window must live in a subquery');
|
|
267
|
+
assert(/order by p\.period_month desc\s+limit 6/s.test(BASELINE_SQL));
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
Deno.test("[S5] the Stripe minimum is applied at RUN level only, never per period", () => {
|
|
271
|
+
assert(ELIGIBILITY_SQL.includes('having sum(p.charge_cents_total) >= 50'));
|
|
272
|
+
assert(ELIGIBILITY_SQL.includes('p.charge_cents_total > 0'));
|
|
273
|
+
// the deleted v14 predicate must not come back
|
|
274
|
+
assert(!/and p\.charge_cents_total >= 50/.test(ELIGIBILITY_SQL));
|
|
275
|
+
assertEquals(STRIPE_MIN_CENTS, 50);
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
// ========================================================== section 4.3 oracle ==
|
|
279
|
+
|
|
280
|
+
Deno.test("[C-05] LAYER 2 uses List Invoices with NO status filter", async () => {
|
|
281
|
+
const { stripe, calls } = mkStripe({ listReturns: [] });
|
|
282
|
+
await runOracle(stripe, { runId: RUN, customerId: CUST, storedInvoiceId: null });
|
|
283
|
+
assertEquals(calls.list, 1);
|
|
284
|
+
assertEquals(calls.retrieve.length, 0); // no stored id -> LAYER 1 skipped
|
|
285
|
+
});
|
|
286
|
+
|
|
287
|
+
Deno.test("round 8 finding 3: a 404 on the stored id is NEVER 'no invoice exists'", async () => {
|
|
288
|
+
// The invoice really is there, findable by metadata — the stored id just 404s.
|
|
289
|
+
const real: StripeInvoice = { id: 'in_real', status: 'open', metadata: { gc_run_id: RUN } };
|
|
290
|
+
const { stripe } = mkStripe({ retrieveThrows: 'notfound', listReturns: [real] });
|
|
291
|
+
const r = await runOracle(stripe, { runId: RUN, customerId: CUST, storedInvoiceId: 'in_stale' });
|
|
292
|
+
assertEquals(r.found, 'yes');
|
|
293
|
+
assertEquals((r as { invoice: StripeInvoice }).invoice.id, 'in_real');
|
|
294
|
+
});
|
|
295
|
+
|
|
296
|
+
Deno.test("a 404 with an EMPTY layer-2 result is marked via404, not a clean 'no'", async () => {
|
|
297
|
+
const { stripe } = mkStripe({ retrieveThrows: 'notfound', listReturns: [] });
|
|
298
|
+
const r = await runOracle(stripe, { runId: RUN, customerId: CUST, storedInvoiceId: 'in_stale' });
|
|
299
|
+
assertEquals(r.found, 'no');
|
|
300
|
+
assertEquals((r as { via404: boolean }).via404, true);
|
|
301
|
+
});
|
|
302
|
+
|
|
303
|
+
Deno.test("a transient (non-404) error returns 'unknown', never 'no'", async () => {
|
|
304
|
+
const { stripe } = mkStripe({ retrieveThrows: 'transient' });
|
|
305
|
+
const r = await runOracle(stripe, { runId: RUN, customerId: CUST, storedInvoiceId: 'in_x' });
|
|
306
|
+
assertEquals(r.found, 'unknown');
|
|
307
|
+
});
|
|
308
|
+
|
|
309
|
+
Deno.test("two invoices carrying the same gc_run_id is a conflict, never a pick-one", async () => {
|
|
310
|
+
const dup = [
|
|
311
|
+
{ id: 'in_a', status: 'draft', metadata: { gc_run_id: RUN } },
|
|
312
|
+
{ id: 'in_b', status: 'draft', metadata: { gc_run_id: RUN } },
|
|
313
|
+
];
|
|
314
|
+
const { stripe } = mkStripe({ listReturns: dup });
|
|
315
|
+
const r = await runOracle(stripe, { runId: RUN, customerId: CUST, storedInvoiceId: null });
|
|
316
|
+
assertEquals(r.found, 'conflict');
|
|
317
|
+
});
|
|
318
|
+
|
|
319
|
+
// ==================================================== section 4.4 routing table ==
|
|
320
|
+
|
|
321
|
+
Deno.test("row 1 — release is reachable from EXACTLY ONE state", () => {
|
|
322
|
+
// claimed + no stored id + verified-empty list
|
|
323
|
+
assertEquals(
|
|
324
|
+
decideRecoveryAction('claimed', null, { found: 'no', via404: false }).kind, 'release_run');
|
|
325
|
+
// ...and from nothing else.
|
|
326
|
+
assertEquals(
|
|
327
|
+
decideRecoveryAction('claimed', 'in_x', { found: 'no', via404: true }).kind, 'hold');
|
|
328
|
+
assertEquals(
|
|
329
|
+
decideRecoveryAction('invoice_created', 'in_x', { found: 'no', via404: true }).kind, 'hold');
|
|
330
|
+
assertEquals(
|
|
331
|
+
decideRecoveryAction('items_posted', 'in_x', { found: 'no', via404: true }).kind, 'hold');
|
|
332
|
+
});
|
|
333
|
+
|
|
334
|
+
Deno.test("T-55 / T-57 — a 404'd stored id HOLDS, it does not release", () => {
|
|
335
|
+
const a = decideRecoveryAction('items_posted', 'in_gone', { found: 'no', via404: true });
|
|
336
|
+
assertEquals(a.kind, 'hold');
|
|
337
|
+
assertEquals((a as { reason: string }).reason, 'invoice_404_unverified');
|
|
338
|
+
});
|
|
339
|
+
|
|
340
|
+
Deno.test("T-58b — claimed with a NULL id but a real draft at Stripe ADOPTS, never releases", () => {
|
|
341
|
+
// The invoice POST succeeded and the process died before T2's write-back. The
|
|
342
|
+
// shortcut "claimed + NULL id => nothing exists" would bill a second invoice.
|
|
343
|
+
const a = decideRecoveryAction('claimed', null,
|
|
344
|
+
{ found: 'yes', invoice: { id: 'in_draft', status: 'draft' } });
|
|
345
|
+
assertEquals(a.kind, 'adopt_draft');
|
|
346
|
+
});
|
|
347
|
+
|
|
348
|
+
Deno.test("rows 11/12 — finalize succeeded but the response was lost -> adopt as billed", () => {
|
|
349
|
+
const open = decideRecoveryAction('items_posted', 'in_1',
|
|
350
|
+
{ found: 'yes', invoice: { id: 'in_1', status: 'open' } });
|
|
351
|
+
assertEquals(open.kind, 'adopt_finalized');
|
|
352
|
+
assertEquals((open as { paid: boolean }).paid, false);
|
|
353
|
+
|
|
354
|
+
const paid = decideRecoveryAction('items_posted', 'in_1',
|
|
355
|
+
{ found: 'yes', invoice: { id: 'in_1', status: 'paid' } });
|
|
356
|
+
assertEquals((paid as { paid: boolean }).paid, true);
|
|
357
|
+
});
|
|
358
|
+
|
|
359
|
+
Deno.test("row 13 — a void/uncollectible invoice is an out-of-band action -> hold", () => {
|
|
360
|
+
for (const st of ['void', 'uncollectible']) {
|
|
361
|
+
const a = decideRecoveryAction('items_posted', 'in_1',
|
|
362
|
+
{ found: 'yes', invoice: { id: 'in_1', status: st } });
|
|
363
|
+
assertEquals(a.kind, 'hold');
|
|
364
|
+
assertEquals((a as { reason: string }).reason, 'invoice_terminal_out_of_band');
|
|
365
|
+
}
|
|
366
|
+
});
|
|
367
|
+
|
|
368
|
+
Deno.test("row 16 — 'finalizing' carries no extra information and routes as items_posted", () => {
|
|
369
|
+
const a = decideRecoveryAction('finalizing', 'in_1',
|
|
370
|
+
{ found: 'yes', invoice: { id: 'in_1', status: 'draft' } });
|
|
371
|
+
assertEquals(a.kind, 'refinalize');
|
|
372
|
+
});
|
|
373
|
+
|
|
374
|
+
Deno.test("rows 19-22 — every terminal run state is a no-op for automation", () => {
|
|
375
|
+
for (const st of ['billed', 'held', 'released', 'failed']) {
|
|
376
|
+
assertEquals(decideRecoveryAction(st, 'in_1',
|
|
377
|
+
{ found: 'yes', invoice: { id: 'in_1', status: 'open' } }).kind, 'noop');
|
|
378
|
+
}
|
|
379
|
+
});
|
|
380
|
+
|
|
381
|
+
Deno.test("rows 4/9/15 — an unknown oracle result always retries, never decides", () => {
|
|
382
|
+
for (const st of ['claimed', 'invoice_created', 'items_posted', 'finalizing']) {
|
|
383
|
+
assertEquals(decideRecoveryAction(st, 'in_1', { found: 'unknown' }).kind, 'retry');
|
|
384
|
+
}
|
|
385
|
+
});
|
|
386
|
+
|
|
387
|
+
// ======================================================= the run, end to end ==
|
|
388
|
+
|
|
389
|
+
Deno.test("happy path — one invoice, one item per period, ONE finalize call", async () => {
|
|
390
|
+
const { stripe, calls } = mkStripe();
|
|
391
|
+
const { db, st } = mkDb();
|
|
392
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
393
|
+
|
|
394
|
+
assertEquals(r.status, 'billed');
|
|
395
|
+
assertEquals(calls.create.length, 1);
|
|
396
|
+
assertEquals(calls.items.length, 2);
|
|
397
|
+
assertEquals(calls.finalize.length, 1); // C-06: ONE call, not two
|
|
398
|
+
assertEquals(calls.create[0].auto_advance, false); // C-06: NOT true at creation
|
|
399
|
+
assertEquals(st.holds.length, 0);
|
|
400
|
+
assertEquals(NETWORK_ATTEMPTS.length, 0);
|
|
401
|
+
});
|
|
402
|
+
|
|
403
|
+
Deno.test("[R2] the idempotency keys are deterministic AND actually sent", async () => {
|
|
404
|
+
const { stripe, calls } = mkStripe();
|
|
405
|
+
const { db } = mkDb();
|
|
406
|
+
await executeBillingRun(stripe, db, INPUT);
|
|
407
|
+
assert(calls.idem.includes(runKey(RUN)));
|
|
408
|
+
assert(calls.idem.includes(itemKey(RUN, P1)));
|
|
409
|
+
assert(calls.idem.includes(itemKey(RUN, P2)));
|
|
410
|
+
assert(calls.idem.includes(finalizeKey(RUN)));
|
|
411
|
+
});
|
|
412
|
+
|
|
413
|
+
Deno.test("C-06 — auto_advance is passed to FINALIZE, and finalize is called once", async () => {
|
|
414
|
+
let finalizeParams: Record<string, unknown> | null = null;
|
|
415
|
+
const { stripe, calls } = mkStripe();
|
|
416
|
+
const orig = stripe.invoices.finalize;
|
|
417
|
+
stripe.invoices.finalize = (id, p, o) => { finalizeParams = p; return orig(id, p, o); };
|
|
418
|
+
const { db } = mkDb();
|
|
419
|
+
await executeBillingRun(stripe, db, INPUT);
|
|
420
|
+
assertEquals(finalizeParams!.auto_advance, true);
|
|
421
|
+
assertEquals(calls.finalize.length, 1);
|
|
422
|
+
});
|
|
423
|
+
|
|
424
|
+
Deno.test("T-26h — the dedup oracle reads the ITEM id, so items are not skipped", async () => {
|
|
425
|
+
// M-14 stamps stripe_invoice_id on every claimed period at STEP 2.5. An oracle
|
|
426
|
+
// keyed on THAT column would skip the whole loop and finalize a $0.00 invoice.
|
|
427
|
+
const { stripe, calls } = mkStripe();
|
|
428
|
+
const { db, st } = mkDb();
|
|
429
|
+
await executeBillingRun(stripe, db, INPUT);
|
|
430
|
+
assertEquals(calls.items.length, 2);
|
|
431
|
+
// every period ended up carrying the invoice id (B10-1's stamp)
|
|
432
|
+
assert(Object.values(st.periods).every((p) => p.stripe_invoice_id === 'in_created'));
|
|
433
|
+
});
|
|
434
|
+
|
|
435
|
+
Deno.test("T-52 — a period that already has an ii_ is SKIPPED on resume (no duplicate line)", async () => {
|
|
436
|
+
const { stripe, calls } = mkStripe();
|
|
437
|
+
const { db, st } = mkDb();
|
|
438
|
+
st.periods[P1].stripe_invoice_item_id = 'ii_already';
|
|
439
|
+
await postItemsAndFinalize(stripe, db, INPUT, 'lease-1', 'in_created');
|
|
440
|
+
assertEquals(calls.items.length, 1); // only P2
|
|
441
|
+
});
|
|
442
|
+
|
|
443
|
+
Deno.test("T-118f [B11-1] a period no longer claimed by this run HOLDS, and posts nothing", async () => {
|
|
444
|
+
const { stripe, calls } = mkStripe();
|
|
445
|
+
const { db, st } = mkDb();
|
|
446
|
+
st.periods[P2].billing_run_id = null; // released out from under the live run
|
|
447
|
+
const r = await postItemsAndFinalize(stripe, db, INPUT, 'lease-1', 'in_created');
|
|
448
|
+
|
|
449
|
+
assertEquals(r.status, 'held');
|
|
450
|
+
assertEquals(st.holds[0], `period_no_longer_claimed_by_this_run: ${P2}`);
|
|
451
|
+
assertEquals(calls.items.length, 1); // P1 posted, P2 NEVER posted
|
|
452
|
+
assertEquals(calls.finalize.length, 0); // and the invoice was not finalized
|
|
453
|
+
});
|
|
454
|
+
|
|
455
|
+
Deno.test("T-56 — a wrong-account key aborts BEFORE the claim; nothing is written", async () => {
|
|
456
|
+
const { stripe, calls } = mkStripe({ accountId: 'acct_someone_else' });
|
|
457
|
+
const { db, st } = mkDb();
|
|
458
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
459
|
+
|
|
460
|
+
assertEquals(r.status, 'aborted_preflight');
|
|
461
|
+
assertEquals(calls.create.length, 0);
|
|
462
|
+
assertEquals(st.writebacks.length, 0);
|
|
463
|
+
assertEquals(st.holds.length, 0);
|
|
464
|
+
});
|
|
465
|
+
|
|
466
|
+
Deno.test("livemode mismatch also aborts preflight", async () => {
|
|
467
|
+
const { stripe } = mkStripe({ livemode: true });
|
|
468
|
+
const { db } = mkDb();
|
|
469
|
+
const r = await executeBillingRun(stripe, db, { ...INPUT, expectedLivemode: false });
|
|
470
|
+
assertEquals(r.status, 'aborted_preflight');
|
|
471
|
+
});
|
|
472
|
+
|
|
473
|
+
Deno.test("GC002 on claim is BENIGN — exit 0, recovery owns the other run", async () => {
|
|
474
|
+
const { stripe, calls } = mkStripe();
|
|
475
|
+
const { db, st } = mkDb({ claimThrows: 'GC002' });
|
|
476
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
477
|
+
assertEquals(r.exitCode, 0);
|
|
478
|
+
assertEquals(r.status, 'already_in_flight');
|
|
479
|
+
assertEquals(calls.create.length, 0);
|
|
480
|
+
assertEquals(st.ops.length, 0);
|
|
481
|
+
});
|
|
482
|
+
|
|
483
|
+
Deno.test("GC003 pages staff from OUTSIDE the rolled-back transaction, and exits 1", async () => {
|
|
484
|
+
const { stripe, calls } = mkStripe();
|
|
485
|
+
const { db, st } = mkDb({ claimThrows: 'GC003' });
|
|
486
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
487
|
+
assertEquals(r.exitCode, 1);
|
|
488
|
+
assertEquals(st.ops[0].kind, 'print_billing_partial_claim');
|
|
489
|
+
assertEquals(st.ops[0].severity, 'error');
|
|
490
|
+
assertEquals(calls.create.length, 0); // never reached Stripe
|
|
491
|
+
});
|
|
492
|
+
|
|
493
|
+
Deno.test("T-50 — invoice_create fails and nothing exists at Stripe -> release", async () => {
|
|
494
|
+
const { stripe } = mkStripe({ createThrows: true, listReturns: [] });
|
|
495
|
+
const { db, st } = mkDb();
|
|
496
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
497
|
+
assertEquals(r.status, 'released');
|
|
498
|
+
assertEquals(st.releases, 1);
|
|
499
|
+
});
|
|
500
|
+
|
|
501
|
+
Deno.test("T-51 — invoice_create 'fails' but the invoice EXISTS -> adopt, never a 2nd invoice", async () => {
|
|
502
|
+
const existing: StripeInvoice = { id: 'in_orphan', status: 'draft', metadata: { gc_run_id: RUN } };
|
|
503
|
+
const { stripe, calls } = mkStripe({ createThrows: true, listReturns: [existing] });
|
|
504
|
+
const { db, st } = mkDb();
|
|
505
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
506
|
+
|
|
507
|
+
assertEquals(r.status, 'billed');
|
|
508
|
+
assertEquals(r.invoiceId, 'in_orphan');
|
|
509
|
+
assertEquals(st.releases, 0); // the double-charge path is NOT taken
|
|
510
|
+
assertEquals(calls.create.length, 1); // exactly the one failed attempt
|
|
511
|
+
});
|
|
512
|
+
|
|
513
|
+
Deno.test("T-54 — finalize dispatched, response dropped, invoice actually OPEN -> charged once", async () => {
|
|
514
|
+
const { stripe, calls } = mkStripe({ finalizeThrows: true, invoiceStatus: 'open' });
|
|
515
|
+
const { db, st } = mkDb();
|
|
516
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
517
|
+
|
|
518
|
+
assertEquals(r.status, 'billed');
|
|
519
|
+
assertEquals(st.releases, 0);
|
|
520
|
+
assertEquals(st.holds.length, 0);
|
|
521
|
+
// exactly ONE finalize attempt was made; the oracle resolved the rest
|
|
522
|
+
assertEquals(calls.finalize.length, 1);
|
|
523
|
+
const billed = st.writebacks.filter((w) => w.status === 'billed');
|
|
524
|
+
assertEquals(billed.length, 1);
|
|
525
|
+
});
|
|
526
|
+
|
|
527
|
+
Deno.test("T-54b — a finalize failure NEVER releases, even when List comes back empty", async () => {
|
|
528
|
+
// R4's finding, as a routing assertion. The run is at items_posted with a real
|
|
529
|
+
// stored invoice id; an empty LAYER 2 must HOLD (row 14), never release (row 1).
|
|
530
|
+
const { stripe } = mkStripe({ finalizeThrows: true, retrieveThrows: 'notfound', listReturns: [] });
|
|
531
|
+
const { db, st } = mkDb();
|
|
532
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
533
|
+
|
|
534
|
+
assertEquals(r.status, 'held');
|
|
535
|
+
assertEquals(st.holds[0], 'invoice_404_unverified');
|
|
536
|
+
assertEquals(st.releases, 0);
|
|
537
|
+
});
|
|
538
|
+
|
|
539
|
+
Deno.test("T-52b — an item_post failure resumes against the SAME draft, never releases", async () => {
|
|
540
|
+
const { stripe, calls } = mkStripe({ itemThrows: true });
|
|
541
|
+
const { db, st } = mkDb();
|
|
542
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
543
|
+
|
|
544
|
+
// the oracle is asked about the invoice we actually created, by its id
|
|
545
|
+
assert(calls.retrieve.includes('in_created'));
|
|
546
|
+
assertEquals(st.releases, 0);
|
|
547
|
+
assert(r.status !== 'released');
|
|
548
|
+
});
|
|
549
|
+
|
|
550
|
+
Deno.test("STEP 4.4 — the il_ line ids section 6 needs are resolved and written back", async () => {
|
|
551
|
+
const { stripe } = mkStripe();
|
|
552
|
+
const { db, st } = mkDb();
|
|
553
|
+
await executeBillingRun(stripe, db, INPUT);
|
|
554
|
+
const billed = st.writebacks.find((w) => w.status === 'billed')!;
|
|
555
|
+
assertEquals((billed.detail[P1] as { line_id: string }).line_id, 'il_1');
|
|
556
|
+
assertEquals((billed.detail[P2] as { line_id: string }).line_id, 'il_2');
|
|
557
|
+
});
|
|
558
|
+
|
|
559
|
+
Deno.test("lease lost (GC005) exits immediately and writes nothing (row 18)", async () => {
|
|
560
|
+
const { stripe, calls } = mkStripe();
|
|
561
|
+
const { db, st } = mkDb();
|
|
562
|
+
db.attemptBump = () => Promise.reject(Object.assign(new Error('lost'), { gcCode: 'GC005' }));
|
|
563
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
564
|
+
assertEquals(r.exitCode, 0);
|
|
565
|
+
assertEquals(r.status, 'lease_lost');
|
|
566
|
+
assertEquals(calls.create.length, 0);
|
|
567
|
+
assertEquals(st.writebacks.length, 0);
|
|
568
|
+
});
|
|
569
|
+
|
|
570
|
+
Deno.test("attempt_count > 3 holds before any invoice is created (row 17)", async () => {
|
|
571
|
+
const { stripe, calls } = mkStripe();
|
|
572
|
+
const { db, st } = mkDb();
|
|
573
|
+
db.attemptBump = () => Promise.resolve(4);
|
|
574
|
+
const r = await executeBillingRun(stripe, db, INPUT);
|
|
575
|
+
assertEquals(r.status, 'held');
|
|
576
|
+
assertEquals(st.holds[0], 'attempt_count exceeded before invoice creation');
|
|
577
|
+
assertEquals(calls.create.length, 0);
|
|
578
|
+
});
|
|
579
|
+
|
|
580
|
+
// ====================================================== section 5 recovery sweep ==
|
|
581
|
+
|
|
582
|
+
Deno.test("section 5.2 — a run that cannot be leased is SKIPPED SILENTLY, not errored", async () => {
|
|
583
|
+
const { stripe } = mkStripe();
|
|
584
|
+
const { db } = mkDb();
|
|
585
|
+
const run: RunRow = {
|
|
586
|
+
id: RUN, membership_id: MEMBERSHIP, status: 'claimed', stripe_customer_id: CUST,
|
|
587
|
+
stripe_invoice_id: null, period_ids: [P1, P2], attempt_count: 1, created_at: 'x',
|
|
588
|
+
};
|
|
589
|
+
db.recoverySelect = () => Promise.resolve([run]);
|
|
590
|
+
db.leaseAcquire = () => Promise.resolve(null); // someone else got there first
|
|
591
|
+
|
|
592
|
+
const out = await runRecoverySweep({
|
|
593
|
+
stripe, db, expectedAccountId: ACCT, expectedLivemode: false,
|
|
594
|
+
loadRunInput: () => Promise.resolve(INPUT),
|
|
595
|
+
});
|
|
596
|
+
assertEquals(out[0].status, 'skipped_not_acquired');
|
|
597
|
+
assertEquals(out[0].ok, true); // NOT an error — round 7 finding 1's shape
|
|
598
|
+
});
|
|
599
|
+
|
|
600
|
+
Deno.test("T-58 — a run recovered by lease age alone routes on the ORACLE, not on intent", async () => {
|
|
601
|
+
// No failure origin is recorded anywhere (section 4.4.1): this is the NORMAL case.
|
|
602
|
+
const existing: StripeInvoice = { id: 'in_found', status: 'draft', metadata: { gc_run_id: RUN } };
|
|
603
|
+
const { stripe } = mkStripe({ listReturns: [existing] });
|
|
604
|
+
const { db, st } = mkDb();
|
|
605
|
+
const run: RunRow = {
|
|
606
|
+
id: RUN, membership_id: MEMBERSHIP, status: 'claimed', stripe_customer_id: CUST,
|
|
607
|
+
stripe_invoice_id: null, period_ids: [P1, P2], attempt_count: 1, created_at: 'x',
|
|
608
|
+
};
|
|
609
|
+
db.recoverySelect = () => Promise.resolve([run]);
|
|
610
|
+
|
|
611
|
+
const out = await runRecoverySweep({
|
|
612
|
+
stripe, db, expectedAccountId: ACCT, expectedLivemode: false,
|
|
613
|
+
loadRunInput: () => Promise.resolve(INPUT),
|
|
614
|
+
});
|
|
615
|
+
assertEquals(out[0].status, 'billed');
|
|
616
|
+
assertEquals(st.releases, 0);
|
|
617
|
+
});
|
|
618
|
+
|
|
619
|
+
Deno.test("the recovery sweep aborts entirely on a preflight mismatch", async () => {
|
|
620
|
+
const { stripe } = mkStripe({ accountId: 'acct_wrong' });
|
|
621
|
+
const { db } = mkDb();
|
|
622
|
+
db.recoverySelect = () => { throw new Error('must not be reached'); };
|
|
623
|
+
const out = await runRecoverySweep({
|
|
624
|
+
stripe, db, expectedAccountId: ACCT, expectedLivemode: false,
|
|
625
|
+
loadRunInput: () => Promise.resolve(INPUT),
|
|
626
|
+
});
|
|
627
|
+
assertEquals(out[0].status, 'aborted_preflight');
|
|
628
|
+
});
|
|
629
|
+
|
|
630
|
+
// ============================================ STEP 0.4 / C-13 payment method ==
|
|
631
|
+
//
|
|
632
|
+
// T-81 and friends: private.print_billing_resolve_customer (the DB function)
|
|
633
|
+
// cannot itself resolve the SUBSCRIPTION's payment method — no synchronous
|
|
634
|
+
// HTTP extension in this Postgres (C-03) means a SQL/stable function cannot
|
|
635
|
+
// call Stripe. resolveDefaultPaymentMethod() is the real STEP 0.4 resolution,
|
|
636
|
+
// against a live Stripe client, and this is what T-81 actually exercises: the
|
|
637
|
+
// "3 of 20 live subscriptions have a different card than the customer's own
|
|
638
|
+
// default" divergence case, not merely that SOME payment method comes back.
|
|
639
|
+
|
|
640
|
+
Deno.test("T-81 — the SUBSCRIPTION's card is charged when it diverges from the customer default", async () => {
|
|
641
|
+
// This is the 3-of-20 case verbatim: the subscription's default_payment_method
|
|
642
|
+
// is a DIFFERENT payment method than the customer's own invoice_settings
|
|
643
|
+
// default. Branch (a) must win.
|
|
644
|
+
const { stripe, calls } = mkStripe({
|
|
645
|
+
subscription: { id: 'sub_1', default_payment_method: 'pm_subscription_card' },
|
|
646
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
647
|
+
});
|
|
648
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
649
|
+
stripeCustomerId: CUST,
|
|
650
|
+
stripeSubscriptionId: 'sub_1',
|
|
651
|
+
});
|
|
652
|
+
assertEquals(pm, 'pm_subscription_card');
|
|
653
|
+
// the subscription must actually have been consulted, not skipped
|
|
654
|
+
assert(calls.subRetrieve.includes('sub_1'));
|
|
655
|
+
});
|
|
656
|
+
|
|
657
|
+
Deno.test("T-81b — an EXPANDED subscription.default_payment_method object resolves to its id", async () => {
|
|
658
|
+
// Stripe sometimes returns an expanded payment_method object rather than a
|
|
659
|
+
// bare id string; either shape must resolve correctly.
|
|
660
|
+
const { stripe } = mkStripe({
|
|
661
|
+
subscription: { id: 'sub_1', default_payment_method: { id: 'pm_expanded_sub_card' } },
|
|
662
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
663
|
+
});
|
|
664
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
665
|
+
stripeCustomerId: CUST,
|
|
666
|
+
stripeSubscriptionId: 'sub_1',
|
|
667
|
+
});
|
|
668
|
+
assertEquals(pm, 'pm_expanded_sub_card');
|
|
669
|
+
});
|
|
670
|
+
|
|
671
|
+
Deno.test("T-81c — no live subscription falls straight to the customer default (branch b)", async () => {
|
|
672
|
+
const { stripe, calls } = mkStripe({
|
|
673
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
674
|
+
});
|
|
675
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
676
|
+
stripeCustomerId: CUST,
|
|
677
|
+
stripeSubscriptionId: null,
|
|
678
|
+
});
|
|
679
|
+
assertEquals(pm, 'pm_customer_default_card');
|
|
680
|
+
assertEquals(calls.subRetrieve.length, 0); // never consulted -- there is no sub
|
|
681
|
+
});
|
|
682
|
+
|
|
683
|
+
Deno.test("T-81d — a subscription with NO default_payment_method falls through to (b)", async () => {
|
|
684
|
+
const { stripe } = mkStripe({
|
|
685
|
+
subscription: { id: 'sub_1', default_payment_method: null },
|
|
686
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
687
|
+
});
|
|
688
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
689
|
+
stripeCustomerId: CUST,
|
|
690
|
+
stripeSubscriptionId: 'sub_1',
|
|
691
|
+
});
|
|
692
|
+
assertEquals(pm, 'pm_customer_default_card');
|
|
693
|
+
});
|
|
694
|
+
|
|
695
|
+
Deno.test("T-81e — a subscription that fails to retrieve (stale/deleted id) falls through to (b), never aborts", async () => {
|
|
696
|
+
const { stripe } = mkStripe({
|
|
697
|
+
subscriptionThrows: true,
|
|
698
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
699
|
+
});
|
|
700
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
701
|
+
stripeCustomerId: CUST,
|
|
702
|
+
stripeSubscriptionId: 'sub_stale',
|
|
703
|
+
});
|
|
704
|
+
assertEquals(pm, 'pm_customer_default_card');
|
|
705
|
+
});
|
|
706
|
+
|
|
707
|
+
Deno.test("T-81f — branch (c): neither the subscription nor the customer specify one -> null, not an error", async () => {
|
|
708
|
+
const { stripe } = mkStripe({
|
|
709
|
+
subscription: { id: 'sub_1', default_payment_method: null },
|
|
710
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: null } },
|
|
711
|
+
});
|
|
712
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
713
|
+
stripeCustomerId: CUST,
|
|
714
|
+
stripeSubscriptionId: 'sub_1',
|
|
715
|
+
});
|
|
716
|
+
assertEquals(pm, null);
|
|
717
|
+
});
|
|
718
|
+
|
|
719
|
+
Deno.test("T-81g — a customer retrieve failure after an empty subscription also resolves to null, not a throw", async () => {
|
|
720
|
+
const { stripe } = mkStripe({
|
|
721
|
+
subscription: { id: 'sub_1', default_payment_method: null },
|
|
722
|
+
customerThrows: true,
|
|
723
|
+
});
|
|
724
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
725
|
+
stripeCustomerId: CUST,
|
|
726
|
+
stripeSubscriptionId: 'sub_1',
|
|
727
|
+
});
|
|
728
|
+
assertEquals(pm, null);
|
|
729
|
+
});
|
|
730
|
+
|
|
731
|
+
Deno.test("T-81h — end to end: executeBillingRun's invoice carries the SUBSCRIPTION's card, not the customer's", async () => {
|
|
732
|
+
// Ties the divergence case to the actual invoice creation call, mirroring how
|
|
733
|
+
// print-billing-run/index.ts wires resolveDefaultPaymentMethod's result into
|
|
734
|
+
// RunInput.defaultPaymentMethod (STEP 2.3).
|
|
735
|
+
const { stripe, calls } = mkStripe({
|
|
736
|
+
subscription: { id: 'sub_1', default_payment_method: 'pm_subscription_card' },
|
|
737
|
+
customer: { id: CUST, invoice_settings: { default_payment_method: 'pm_customer_default_card' } },
|
|
738
|
+
});
|
|
739
|
+
const pm = await resolveDefaultPaymentMethod(stripe, {
|
|
740
|
+
stripeCustomerId: CUST,
|
|
741
|
+
stripeSubscriptionId: 'sub_1',
|
|
742
|
+
});
|
|
743
|
+
const { db } = mkDb();
|
|
744
|
+
await executeBillingRun(stripe, db, { ...INPUT, defaultPaymentMethod: pm });
|
|
745
|
+
assertEquals(calls.create[0].default_payment_method, 'pm_subscription_card');
|
|
746
|
+
});
|
|
747
|
+
|
|
748
|
+
Deno.test("NO NETWORK was attempted by any test in this file", () => {
|
|
749
|
+
assertEquals(NETWORK_ATTEMPTS, []);
|
|
750
|
+
});
|