Skip to content
Sign in

flagon-io/g1t

public
0

g1t/services/billing/src/statement.rs

586 lines25,186 bytesCodeBlame
1//! A workspace's statement: a month of its ledger, grouped so it can be
2//! read at a glance (by day or by project, a line per kind of charge),
3//! with each line's entries a page at a time.
4
5use g1t_contracts::billing::{
6 Covered, LedgerEntry, MeterUsage, Statement, StatementArgs, StatementEntriesArgs, StatementGroup, StatementLine, StatementTotals,
7 UsageMetersArgs,
8};
9use g1t_contracts::time::rfc3339;
10use g1t_contracts::Outcome;
11use g1t_kit::now_ms;
12use serde::Deserialize;
13use worker::Result;
14use worker::wasm_bindgen::JsValue;
15
16use crate::{Billing, LedgerRow, members_only};
17
18/// Entries in one page of a line.
19const PAGE: u32 = 50;
20
21/// The kind of charge a ledger row is, as the statement names it. One SQL
22/// expression, so grouping and filtering agree.
23/// `Runs on your own model provider` is only on older months: those runs
24/// carried a flat fee then, and pay only their sandbox time now.
25pub(crate) const KIND_SQL: &str = "CASE
26 WHEN kind = 'top_up' AND credit_kind = 'purchased' THEN 'AI credit'
27 WHEN kind = 'top_up' AND reference LIKE 'crd%' THEN 'Credits from g1t'
28 WHEN kind = 'top_up' AND amount_micros < 0 THEN 'Refunds'
29 WHEN kind = 'top_up' THEN 'Payments'
30 WHEN task = 'sandbox' THEN 'Sandbox time'
31 WHEN task = 'self_hosted' THEN 'Self-hosted runner time'
32 WHEN task = 'deployments' THEN 'Deployments'
33 WHEN task = 'security' THEN 'Security scans'
34 WHEN task = 'context' THEN 'Search embeddings'
35 WHEN task = 'storage' THEN 'Private storage'
36 WHEN task = 'cache' THEN 'Actions cache storage'
37 WHEN task = 'git' THEN 'Git operations'
38 WHEN reference LIKE '%/agent-own%' THEN 'Agent rate, your own model key'
39 WHEN billed_to = 'workspace' THEN 'Runs on your own model provider'
40 WHEN reference LIKE '%/agent%' THEN 'Agent rate'
41 WHEN task = 'gateway' THEN 'AI Gateway'
42 WHEN task = 'domains' THEN 'Custom domains'
43 WHEN task = 'package_storage' THEN 'Package storage'
44 ELSE 'Agent runs' END";
45
46/// A usage line at its price, in SQL: what was charged, what paid for it
47/// first (the plan's included usage, the trial, a pool, g1t), and what a
48/// discount took off. `line_price`, for a whole column. The one measure of
49/// usage every page shows.
50pub(crate) const PRICE_SQL: &str = "(-amount_micros + COALESCE(credit_micros, 0) + COALESCE(trial_micros, 0) + COALESCE(oss_micros, 0)
51 + COALESCE(given_micros, 0) + COALESCE(discount_micros, 0))";
52
53/// Whether a usage line is an agent run's own line (`run_…`), not its
54/// agent rate, a correction or anything else: what counts as one run.
55pub(crate) const RUN_SQL: &str = "(reference LIKE 'run%' AND instr(reference, '/') = 0)";
56
57/// The order lines appear in within a group.
58pub(crate) fn kind_order(kind: &str) -> u8 {
59 match kind {
60 "Agent runs" => 0,
61 "Agent rate" => 0,
62 "Agent rate, your own model key" => 0,
63 "AI Gateway" => 1,
64 "Runs on your own model provider" => 1,
65 "Sandbox time" => 2,
66 "Self-hosted runner time" => 2,
67 "Deployments" => 3,
68 "Private storage" => 4,
69 "Actions cache storage" => 4,
70 "Git operations" => 5,
71 "Search embeddings" => 6,
72 "Security scans" => 7,
73 "Custom domains" => 3,
74 "Package storage" => 4,
75 "Payments" => 8,
76 "AI credit" => 8,
77 "Credits from g1t" => 9,
78 "Refunds" => 10,
79 "Tax" => 8,
80 "Card processing fees" => 8,
81 _ => 11,
82 }
83}
84
85/// Payments, credits and refunds: money in, which has no price.
86pub(crate) fn is_money_in(kind: &str) -> bool {
87 matches!(kind, "Payments" | "AI credit" | "Credits from g1t" | "Refunds" | "Tax" | "Card processing fees")
88}
89
90/// A usage line at its price: what was charged, what paid for it first,
91/// and what the account's discount took off.
92pub(crate) fn line_price(charged: i64, covered: i64, discount: i64) -> i64 {
93 charged + covered + discount
94}
95
96/// The Billing page's meters, in order: key and label.
97pub(crate) const METERS: [(&str, &str); 6] = [
98 ("agents", "Agents & sandboxes"),
99 ("builds", "Builds"),
100 ("requests", "Requests & CPU"),
101 ("domains", "Custom domains"),
102 ("git_storage", "Git operations & storage"),
103 ("search_scans", "Search & security scans"),
104];
105
106/// The meter a ledger row's usage is on. One SQL expression, as `KIND_SQL`.
107pub(crate) const METER_SQL: &str = "CASE
108 WHEN task = 'deployments' AND reference LIKE 'deploy/%' THEN 'builds'
109 WHEN task = 'deployments' THEN 'requests'
110 WHEN task IN ('storage', 'git', 'cache') THEN 'git_storage'
111 WHEN task IN ('security', 'context') THEN 'search_scans'
112 ELSE 'agents' END";
113
114/// The meter usage noted through the month (`pending_usage.source`) is on.
115pub(crate) fn meter_of_source(source: &str) -> &'static str {
116 match source {
117 "deployments" => "requests",
118 "domains" => "domains",
119 "storage" | "git" | "cache" => "git_storage",
120 _ => "search_scans",
121 }
122}
123
124/// `41 build minutes`, from seconds, rounded up.
125pub(crate) fn build_minutes(seconds: i64) -> Option<String> {
126 let minutes = (seconds.max(0) + 59) / 60;
127 (seconds > 0).then(|| format!("{} build minute{}", crate::features::thousands(minutes as u64), if minutes == 1 { "" } else { "s" }))
128}
129
130/// `12 runs`.
131pub(crate) fn runs(count: u32) -> Option<String> {
132 (count > 0).then(|| format!("{} run{}", crate::features::thousands(count.into()), if count == 1 { "" } else { "s" }))
133}
134
135/// `12,345 git operations, 0.42 GB private`.
136pub(crate) fn git_and_storage(operations: u64, private_bytes: i64) -> Option<String> {
137 let mut parts = vec![];
138 if operations > 0 {
139 parts.push(format!("{} git operation{}", crate::features::thousands(operations), if operations == 1 { "" } else { "s" }));
140 }
141 if private_bytes > 0 {
142 parts.push(format!("{:.2} GB private", private_bytes as f64 / 1e9));
143 }
144 (!parts.is_empty()).then(|| parts.join(", "))
145}
146
147/// What paid for usage before it was charged, as the statement names it,
148/// with the ledger column that holds it.
149pub(crate) const COVERED: [(&str, &str, &str); 4] = [
150 ("included", "credit_micros", "Paid by your plan's included usage"),
151 ("trial", "trial_micros", "Paid by your trial credit"),
152 ("oss_pool", "oss_micros", "Paid by g1t's open-source pool"),
153 ("given", "given_micros", "Covered by g1t"),
154];
155
156/// The statement's lines for what paid: each source with anything to show.
157pub(crate) fn covered_lines(sums: [i64; 4]) -> Vec<Covered> {
158 COVERED
159 .iter()
160 .zip(sums)
161 .filter(|(_, micros)| *micros > 0)
162 .map(|((source, _, label), micros)| Covered { source: (*source).to_owned(), label: (*label).to_owned(), micros })
163 .collect()
164}
165
166/// `2026-10` and the first instant of the next month, for a range.
167pub(crate) fn month_range(month: &str) -> Option<(String, String)> {
168 let year: i32 = month.get(..4)?.parse().ok()?;
169 let number: u32 = month.get(5..7)?.parse().ok()?;
170 if month.len() != 7 || !(1..=12).contains(&number) {
171 return None;
172 }
173 let next = if number == 12 { format!("{}-01", year + 1) } else { format!("{year}-{:02}", number + 1) };
174 Some((format!("{month}-01"), format!("{next}-01")))
175}
176
177#[derive(Deserialize)]
178struct Row {
179 group_key: Option<String>,
180 kind: String,
181 count: u32,
182 amount: Option<i64>,
183 cost: Option<i64>,
184 credit: Option<i64>,
185 trial: Option<i64>,
186 oss: Option<i64>,
187 given: Option<i64>,
188 discount: Option<i64>,
189}
190
191#[derive(Deserialize)]
192struct Month {
193 month: String,
194}
195
196#[derive(Deserialize)]
197struct ExtraRow {
198 group_key: Option<String>,
199 kind: String,
200 count: u32,
201 amount: Option<i64>,
202}
203
204/// How the statement names a `tax_and_fees` kind.
205pub(crate) fn extra_kind(kind: &str) -> &'static str {
206 if kind == "tax" { "Tax" } else { "Card processing fees" }
207}
208
209/// Puts a line in its group, starting the group if it is new.
210fn add_line(groups: &mut Vec<StatementGroup>, key: String, line: StatementLine) {
211 match groups.iter_mut().find(|g| g.key == key) {
212 Some(group) => group.lines.push(line),
213 None => groups.push(StatementGroup {
214 label: if key.is_empty() { "Not one project".to_owned() } else { key.clone() },
215 key,
216 lines: vec![line],
217 charged_micros: 0,
218 price_micros: 0,
219 discount_micros: 0,
220 }),
221 }
222}
223
224impl Billing {
225 pub(crate) async fn statement(&self, a: StatementArgs) -> Result<Outcome<Statement>> {
226 let workspace = a.workspace.to_lowercase();
227 if !a.viewer.is_some_and(|viewer| viewer.is_member(&workspace)) {
228 return Ok(members_only());
229 }
230 let current = rfc3339(now_ms())[..7].to_owned();
231 let month = a.month.filter(|m| month_range(m).is_some()).unwrap_or(current);
232 let (from, until) = month_range(&month).expect("a valid month");
233 let by_project = a.group.as_deref() == Some("project");
234 let group_sql = if by_project { "COALESCE(repo, '')" } else { "substr(created_at, 1, 10)" };
235 let rows = self
236 .db
237 .prepare(format!(
238 "SELECT {group_sql} AS group_key, {KIND_SQL} AS kind, COUNT(*) AS count,
239 SUM(amount_micros) AS amount, SUM(cost_micros) AS cost,
240 SUM(credit_micros) AS credit, SUM(trial_micros) AS trial, SUM(oss_micros) AS oss,
241 SUM(given_micros) AS given, SUM(discount_micros) AS discount
242 FROM ledger WHERE workspace = ?1 AND created_at >= ?2 AND created_at < ?3
243 GROUP BY 1, 2"
244 ))
245 .bind(&[workspace.as_str().into(), from.as_str().into(), until.as_str().into()])?
246 .all()
247 .await?
248 .results::<Row>()?;
249
250 let mut groups: Vec<StatementGroup> = vec![];
251 let mut covered = [0i64; 4];
252 for row in rows {
253 let key = row.group_key.unwrap_or_default();
254 let amount = row.amount.unwrap_or(0);
255 let paid_for = [row.credit.unwrap_or(0), row.trial.unwrap_or(0), row.oss.unwrap_or(0), row.given.unwrap_or(0)];
256 for (total, micros) in covered.iter_mut().zip(paid_for) {
257 *total += micros;
258 }
259 let discount = row.discount.unwrap_or(0);
260 let line = StatementLine {
261 // Charges positive, money in negative, as a statement reads.
262 charged_micros: -amount,
263 cost_micros: row.cost.unwrap_or(0),
264 covered_micros: paid_for.iter().sum(),
265 price_micros: if is_money_in(&row.kind) { 0 } else { line_price(-amount, paid_for.iter().sum(), discount) },
266 discount_micros: discount,
267 kind: row.kind,
268 count: row.count,
269 passed_micros: 0,
270 };
271 add_line(&mut groups, key, line);
272 }
273 // Tax and card fees paid with the month's payments: their own
274 // lines, beside the payment, never in what was charged or paid.
275 let extras = self
276 .db
277 .prepare(format!(
278 "SELECT {} AS group_key, kind, COUNT(*) AS count, SUM(amount_micros) AS amount
279 FROM tax_and_fees WHERE workspace = ?1 AND created_at >= ?2 AND created_at < ?3 GROUP BY 1, 2",
280 if by_project { "''" } else { "substr(created_at, 1, 10)" }
281 ))
282 .bind(&[workspace.as_str().into(), from.as_str().into(), until.as_str().into()])?
283 .all()
284 .await?
285 .results::<ExtraRow>()?;
286 let (mut tax_micros, mut card_fee_micros) = (0, 0);
287 for extra in extras {
288 let amount = extra.amount.unwrap_or(0);
289 if extra.kind == "tax" {
290 tax_micros += amount;
291 } else {
292 card_fee_micros += amount;
293 }
294 let line = StatementLine {
295 kind: extra_kind(&extra.kind).to_owned(),
296 count: extra.count,
297 charged_micros: 0,
298 cost_micros: 0,
299 covered_micros: 0,
300 price_micros: 0,
301 discount_micros: 0,
302 passed_micros: amount,
303 };
304 add_line(&mut groups, extra.group_key.unwrap_or_default(), line);
305 }
306 for group in &mut groups {
307 group.lines.sort_by_key(|line| kind_order(&line.kind));
308 group.charged_micros = group.lines.iter().filter(|l| l.charged_micros > 0).map(|l| l.charged_micros).sum();
309 group.price_micros = group.lines.iter().map(|l| l.price_micros).sum();
310 group.discount_micros = group.lines.iter().map(|l| l.discount_micros).sum();
311 }
312 if by_project {
313 groups.sort_by_key(|a| std::cmp::Reverse(a.charged_micros));
314 } else {
315 groups.sort_by(|a, b| b.key.cmp(&a.key));
316 }
317 let lines = groups.iter().flat_map(|g| g.lines.iter());
318 let totals = StatementTotals {
319 charged_micros: lines.clone().filter(|l| l.charged_micros > 0).map(|l| l.charged_micros).sum(),
320 paid_micros: lines.clone().filter(|l| l.charged_micros < 0).map(|l| -l.charged_micros).sum(),
321 cost_micros: lines.clone().map(|l| l.cost_micros).sum(),
322 price_micros: lines.clone().map(|l| l.price_micros).sum(),
323 discount_micros: lines.clone().map(|l| l.discount_micros).sum(),
324 discount_percent: Some(self.terms_of(&workspace).await?.percent_off()).filter(|p| *p > 0),
325 entries: lines.map(|l| l.count).sum(),
326 covered: covered_lines(covered),
327 carried_micros: self.carried(&workspace, &month).await?,
328 tax_micros,
329 card_fee_micros,
330 };
331 let months = self
332 .db
333 .prepare("SELECT DISTINCT substr(created_at, 1, 7) AS month FROM ledger WHERE workspace = ? ORDER BY 1 DESC LIMIT 36")
334 .bind(&[workspace.as_str().into()])?
335 .all()
336 .await?
337 .results::<Month>()?
338 .into_iter()
339 .map(|m| m.month)
340 .collect();
341 Ok(Outcome::Ok(Statement { month, months, groups, totals }))
342 }
343
344 /// `usage_meters`: this month's usage by meter, at cost plus the margin
345 /// (with a custom discount, if the account has one) before the plan's
346 /// included usage or a pool paid for any of it. Comped workspaces see
347 /// what it would cost. Usage charged through the month is on the
348 /// ledger; usage charged when the month closes (app traffic, custom
349 /// domains, storage, git operations, search and scans) is what has been
350 /// noted so far.
351 pub(crate) async fn usage_meters(&self, a: UsageMetersArgs) -> Result<Outcome<Vec<MeterUsage>>> {
352 let workspace = a.workspace.to_lowercase();
353 if !a.viewer.is_some_and(|viewer| viewer.is_member(&workspace)) {
354 return Ok(members_only());
355 }
356 let now = rfc3339(now_ms());
357 let month = now[..7].to_owned();
358 let (from, until) = month_range(&month).expect("a valid month");
359 #[derive(Deserialize)]
360 struct Used {
361 meter: String,
362 count: u32,
363 price: Option<f64>,
364 }
365 // A month's close for deployments is charged in the next month;
366 // it is last month's, so it is left out here.
367 let ledger = self
368 .db
369 .prepare(format!(
370 "SELECT {METER_SQL} AS meter, SUM(CASE WHEN {RUN_SQL} THEN 1 ELSE 0 END) AS count, SUM({PRICE_SQL}) AS price
371 FROM ledger WHERE workspace = ?1 AND kind = 'usage' AND created_at >= ?2 AND created_at < ?3
372 AND COALESCE(reference, '') NOT LIKE 'deployments/%'
373 -- Runs on the workspace's own model provider are its provider's to bill, never g1t's.
374 AND COALESCE(billed_to, 'g1t') = 'g1t'
375 GROUP BY 1"
376 ))
377 .bind(&[workspace.as_str().into(), from.as_str().into(), until.as_str().into()])?
378 .all()
379 .await?
380 .results::<Used>()?;
381 #[derive(Deserialize)]
382 struct Pending {
383 source: String,
384 cost_micros: Option<f64>,
385 detail: Option<String>,
386 }
387 let pending = self
388 .db
389 .prepare("SELECT source, cost_micros, detail FROM pending_usage WHERE workspace = ? AND month = ? AND charged_at IS NULL")
390 .bind(&[workspace.as_str().into(), month.as_str().into()])?
391 .all()
392 .await?
393 .results::<Pending>()?;
394 // At price, before any discount, as every page shows usage: the
395 // ledger's lines as they were charged, and what is metered so far
396 // at cost plus the margin.
397 let price = |cost: i64| crate::credits::with_margin(cost, self.margin_percent);
398 let mut meters: Vec<MeterUsage> = METERS
399 .iter()
400 .map(|(key, label)| MeterUsage { key: (*key).to_owned(), label: (*label).to_owned(), micros: 0, quantity: None })
401 .collect();
402 let mut agent_runs = 0;
403 for used in ledger {
404 if let Some(meter) = meters.iter_mut().find(|m| m.key == used.meter) {
405 meter.micros += used.price.unwrap_or(0.0).round() as i64;
406 }
407 if used.meter == "agents" {
408 agent_runs = used.count;
409 }
410 }
411 for row in &pending {
412 let key = meter_of_source(&row.source);
413 if let Some(meter) = meters.iter_mut().find(|m| m.key == key) {
414 meter.micros += price(row.cost_micros.unwrap_or(0.0).round() as i64);
415 if matches!(key, "requests" | "domains") {
416 meter.quantity = row.detail.clone().filter(|d| !d.is_empty());
417 }
418 }
419 }
420 let build_seconds = self.allowance_used("build_seconds", &workspace, &month).await?;
421 let operations = self.git_operations_this_month(&workspace).await?;
422 let stored = self.private_storage(&workspace).await?;
423 for meter in &mut meters {
424 match meter.key.as_str() {
425 "agents" => meter.quantity = runs(agent_runs),
426 "builds" => meter.quantity = build_minutes(build_seconds),
427 "git_storage" => meter.quantity = git_and_storage(operations, stored),
428 _ => {}
429 }
430 }
431 Ok(Outcome::Ok(meters))
432 }
433
434 /// What was owed when `month` closed but was under the minimum charge,
435 /// and so carried over to the next invoice.
436 async fn carried(&self, workspace: &str, month: &str) -> Result<i64> {
437 #[derive(Deserialize)]
438 struct Row {
439 amount_micros: i64,
440 }
441 Ok(self
442 .db
443 .prepare("SELECT amount_micros FROM month_closes WHERE workspace = ? AND month = ? AND status = 'carried'")
444 .bind(&[workspace.into(), month.into()])?
445 .first::<Row>(None)
446 .await?
447 .map_or(0, |row| row.amount_micros))
448 }
449
450 /// One line's entries, newest first, a page at a time.
451 pub(crate) async fn statement_entries(&self, a: StatementEntriesArgs) -> Result<Outcome<Vec<LedgerEntry>>> {
452 let workspace = a.workspace.to_lowercase();
453 if !a.viewer.is_some_and(|viewer| viewer.is_member(&workspace)) {
454 return Ok(members_only());
455 }
456 let Some((from, until)) = month_range(&a.month) else {
457 return Ok(Outcome::Ok(vec![]));
458 };
459 let mut filters = vec![format!("({KIND_SQL}) = ?4")];
460 let mut values: Vec<JsValue> = vec![
461 workspace.as_str().into(),
462 from.as_str().into(),
463 until.as_str().into(),
464 a.kind.as_str().into(),
465 ];
466 if let Some(day) = a.day.as_deref().filter(|d| d.len() == 10) {
467 values.push(day.into());
468 filters.push(format!("substr(created_at, 1, 10) = ?{}", values.len()));
469 }
470 if let Some(project) = &a.project {
471 values.push(project.as_str().into());
472 filters.push(format!("COALESCE(repo, '') = ?{}", values.len()));
473 }
474 if let Some(before) = &a.before {
475 values.push(before.as_str().into());
476 filters.push(format!("id < ?{}", values.len()));
477 }
478 let rows = self
479 .db
480 .prepare(format!(
481 "SELECT * FROM ledger WHERE workspace = ?1 AND created_at >= ?2 AND created_at < ?3 AND {}
482 ORDER BY id DESC LIMIT {PAGE}",
483 filters.join(" AND ")
484 ))
485 .bind(&values)?
486 .all()
487 .await?
488 .results::<LedgerRow>()?;
489 Ok(Outcome::Ok(rows.into_iter().map(LedgerEntry::from).collect()))
490 }
491}
492
493#[cfg(test)]
494mod tests {
495 use super::*;
496
497 #[test]
498 fn tax_and_card_fees_are_their_own_lines_beside_payments_never_charges() {
499 assert_eq!(extra_kind("tax"), "Tax");
500 assert_eq!(extra_kind("card_fee"), "Card processing fees");
501 for kind in ["Tax", "Card processing fees"] {
502 // Money that came in with a payment: no price, no usage.
503 assert!(is_money_in(kind));
504 assert_eq!(kind_order(kind), kind_order("Payments"));
505 }
506 let mut groups = vec![];
507 let line = |kind: &str, passed: i64| StatementLine {
508 kind: kind.to_owned(),
509 count: 1,
510 charged_micros: 0,
511 cost_micros: 0,
512 covered_micros: 0,
513 price_micros: 0,
514 discount_micros: 0,
515 passed_micros: passed,
516 };
517 add_line(&mut groups, "2026-10-08".into(), line("Tax", 1_640_000));
518 add_line(&mut groups, "2026-10-08".into(), line("Card processing fees", 920_000));
519 assert_eq!(groups.len(), 1);
520 assert!(groups[0].lines.iter().all(|l| l.charged_micros == 0));
521 }
522
523 #[test]
524 fn a_month_runs_to_the_first_of_the_next() {
525 assert_eq!(month_range("2026-10"), Some(("2026-10-01".into(), "2026-11-01".into())));
526 assert_eq!(month_range("2026-12"), Some(("2026-12-01".into(), "2027-01-01".into())));
527 assert_eq!(month_range("2026-13"), None);
528 assert_eq!(month_range("oops"), None);
529 }
530
531 #[test]
532 fn a_discounted_line_shows_its_price_and_the_discount() {
533 // $1.20 of usage on a 100% discount: charged nothing, all of it off.
534 assert_eq!(line_price(0, 0, 1_200_000), 1_200_000);
535 // 30% off, $0.20 of it paid by included usage first.
536 assert_eq!(line_price(700_000, 140_000, 360_000), 1_200_000);
537 assert!(is_money_in("Payments") && is_money_in("Credits from g1t") && is_money_in("Refunds"));
538 assert!(!is_money_in("Agent runs"));
539 }
540
541 #[test]
542 fn usage_lines_come_before_money_in() {
543 assert!(kind_order("Agent runs") < kind_order("Sandbox time"));
544 assert!(kind_order("Deployments") < kind_order("Payments"));
545 assert!(kind_order("Security scans") < kind_order("Payments"));
546 }
547
548 #[test]
549 fn usage_falls_on_the_meters_the_billing_page_shows() {
550 let keys: Vec<_> = METERS.iter().map(|(key, _)| *key).collect();
551 assert_eq!(keys, ["agents", "builds", "requests", "domains", "git_storage", "search_scans"]);
552 assert_eq!(meter_of_source("deployments"), "requests");
553 assert_eq!(meter_of_source("domains"), "domains");
554 assert_eq!(meter_of_source("git"), "git_storage");
555 assert_eq!(meter_of_source("storage"), "git_storage");
556 assert_eq!(meter_of_source("context"), "search_scans");
557 assert_eq!(meter_of_source("security"), "search_scans");
558 for key in ["builds", "requests", "git_storage", "search_scans", "agents"] {
559 assert!(METER_SQL.contains(&format!("'{key}'")));
560 }
561 }
562
563 #[test]
564 fn quantities_read_plainly() {
565 assert_eq!(build_minutes(0), None);
566 assert_eq!(build_minutes(1).as_deref(), Some("1 build minute"));
567 assert_eq!(build_minutes(2_461).as_deref(), Some("42 build minutes"));
568 assert_eq!(runs(1).as_deref(), Some("1 run"));
569 assert_eq!(runs(1_200).as_deref(), Some("1,200 runs"));
570 assert_eq!(git_and_storage(0, 0), None);
571 assert_eq!(git_and_storage(12_345, 420_000_000).as_deref(), Some("12,345 git operations, 0.42 GB private"));
572 assert_eq!(git_and_storage(1, 0).as_deref(), Some("1 git operation"));
573 }
574
575 #[test]
576 fn the_statement_says_what_paid_before_the_workspace_did() {
577 let lines = covered_lines([0, 250_000, 120_000, 0]);
578 assert_eq!(lines.len(), 2);
579 assert_eq!(lines[0].label, "Paid by your trial credit");
580 assert_eq!(lines[1], Covered { source: "oss_pool".into(), label: "Paid by g1t's open-source pool".into(), micros: 120_000 });
581 assert!(covered_lines([0, 0, 0, 0]).is_empty());
582 let lines = covered_lines([4_000_000, 0, 0, 30_000]);
583 assert_eq!(lines[0].label, "Paid by your plan's included usage");
584 assert_eq!(lines[1].label, "Covered by g1t");
585 }
586}