use crate::args::Format;
use crate::cli::Output;
use crate::session::Session;
use crate::tracecmd::{Origin, value};
use std::path::{Path, PathBuf};
#[derive(Default)]
struct Raw {
session: Option<String>,
color: Option<ColorMode>,
format: Format,
chdir: Option<String>,
statusline: bool,
model: Option<String>,
}
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
enum ColorMode {
#[default]
Auto,
Always,
Never,
}
#[derive(Default)]
struct RateConfig {
compact: Option<Compact>,
turn: Option<Threshold>,
total: Option<Threshold>,
hour: Option<Threshold>,
day: Option<Threshold>,
}
#[derive(serde::Deserialize, Debug, Clone, PartialEq, Eq)]
#[serde(untagged)]
enum Compact {
Every(u64),
PerModel(std::collections::BTreeMap<String, u64>),
}
impl Compact {
fn point(&self, model: Option<&str>) -> Option<u64> {
match self {
Self::Every(n) => Some(*n),
Self::PerModel(table) => {
let name = model?;
table
.get(name)
.or_else(|| table.get(crate::models::base_id(name)))
.copied()
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Threshold {
green: u64,
amber: u64,
}
#[derive(serde::Deserialize, Default)]
struct TomlConfig {
rate: Option<TomlRate>,
}
#[derive(serde::Deserialize, Default)]
struct TomlRate {
compact: Option<Compact>,
turn: Option<TomlThreshold>,
total: Option<TomlThreshold>,
hour: Option<TomlThreshold>,
day: Option<TomlThreshold>,
}
#[derive(serde::Deserialize)]
struct TomlThreshold {
green: u64,
amber: u64,
}
#[derive(Default, Debug, Clone, Copy)]
struct Split {
entered: Option<u64>,
cache_read: Option<u64>,
output: Option<u64>,
}
#[derive(Default, Debug, Clone, Copy)]
struct Rates {
per_hour: Option<u64>,
per_day: Option<u64>,
growth_hour: Option<u64>,
growth_day: Option<u64>,
}
struct Throughput {
last_turn: Option<u64>,
total: u64,
growth: u64,
rates: Rates,
split: Split,
turns: usize,
age_seconds: u64,
active_seconds: u64,
compact_at: Option<u64>,
compact_n: usize,
}
pub(crate) fn rate(rest: &[String], input: crate::cli::Input) -> Output {
match parse(rest) {
Ok(mut raw) => {
if raw.statusline
&& let Err(o) = adopt_payload(&mut raw, input)
{
return o;
}
run(&raw)
}
Err(e) => Output::usage_err(format!("itok: {e}")),
}
}
fn adopt_payload(
raw: &mut Raw,
input: crate::cli::Input,
) -> Result<(), Output> {
let payload = crate::hook::statusline(&input());
let Some(transcript) = payload.transcript else {
return Err(Output::usage_err(
"itok: --statusline: no `transcript_path` in the payload on stdin"
.to_owned(),
));
};
raw.session.get_or_insert(transcript);
if let Some(cwd) = payload.cwd {
raw.chdir.get_or_insert(cwd);
}
raw.model = payload.model;
Ok(())
}
fn run(raw: &Raw) -> Output {
let (session, compactions, origin) = match session_of(raw) {
Ok(v) => v,
Err(o) => return o,
};
let Some(tp) = throughput(&session, &compactions) else {
return too_few(raw, &session, &compactions);
};
format_output(raw, &tp, &origin)
}
fn too_few(
raw: &Raw,
session: &Session,
compactions: &[crate::session::Compaction],
) -> Output {
match raw.format {
Format::Json => {
Output::ok(json(&unmeasured(session, compactions), None))
}
Format::Human => Output::ok(String::new()),
}
}
fn unmeasured(
session: &Session,
compactions: &[crate::session::Compaction],
) -> Throughput {
Throughput {
last_turn: last_billed(session),
total: session.billed_input(),
growth: crate::session::growth(&session.turns),
rates: Rates::default(),
split: split_of(session),
turns: session.turns.len(),
age_seconds: 0,
active_seconds: 0,
compact_at: crate::session::compact_point(compactions),
compact_n: crate::session::auto_compactions(compactions).count(),
}
}
fn format_output(raw: &Raw, tp: &Throughput, origin: &Origin) -> Output {
let note = crate::tracecmd::origin_note(origin);
let config = load_config(raw.chdir.as_deref());
let color = want_color(color_of(raw));
let gauge = gauge_of(raw, tp, &config);
Output::ok(match raw.format {
Format::Json => json(tp, gauge.eta),
Format::Human if raw.statusline => {
badge(human(tp, &config, color, gauge))
}
Format::Human => human(tp, &config, color, gauge) + ¬e,
})
}
#[derive(Default, Debug, Clone, Copy)]
struct Gauge {
limit: Option<u64>,
eta: Option<u64>,
}
fn gauge_of(raw: &Raw, tp: &Throughput, config: &RateConfig) -> Gauge {
let limit = red_line(raw, tp, config);
Gauge {
limit,
eta: tp.last_turn.and_then(|used| {
crate::eta::seconds(used, limit, tp.rates.growth_hour)
}),
}
}
fn red_line(raw: &Raw, tp: &Throughput, config: &RateConfig) -> Option<u64> {
let declared = config
.compact
.as_ref()
.and_then(|c| c.point(raw.model.as_deref()));
declared.or(tp.compact_at).or_else(|| {
let root =
std::path::PathBuf::from(raw.chdir.as_deref().unwrap_or("."));
crate::capacity::or_none(None, raw.model.as_deref(), &root)
})
}
fn color_of(raw: &Raw) -> ColorMode {
raw.color.unwrap_or(if raw.statusline {
ColorMode::Always
} else {
ColorMode::Auto
})
}
fn badge(line: String) -> String {
let body = line.trim_end_matches('\n');
if body.is_empty() {
return String::new();
}
format!("(itok:{body})")
}
fn want_color(mode: ColorMode) -> bool {
match mode {
ColorMode::Always => true,
ColorMode::Never => false,
ColorMode::Auto => is_tty(),
}
}
fn session_of(raw: &Raw) -> Result<crate::tracecmd::Loaded, Output> {
crate::tracecmd::session_with_compactions(
raw.session.as_deref(),
raw.chdir.as_deref(),
)
}
fn throughput(
session: &Session,
compactions: &[crate::session::Compaction],
) -> Option<Throughput> {
if session.turns.len() < 2 {
return None;
}
Some(tp_from(sample_of(session, compactions)?))
}
fn sample_of(
session: &Session,
compactions: &[crate::session::Compaction],
) -> Option<Sample> {
let first = session.turns.first()?;
let last = session.turns.last()?;
Some(Sample {
last_turn: last_billed(session),
total: session.billed_input(),
growth: crate::session::growth(&session.turns),
split: split_of(session),
span: age_seconds(&first.ts, &last.ts),
active: active_seconds(&session.turns),
turns: session.turns.len(),
compact_at: crate::session::compact_point(compactions),
compact_n: crate::session::auto_compactions(compactions).count(),
})
}
fn last_billed(session: &Session) -> Option<u64> {
session
.turns
.last()
.and_then(crate::session::Turn::billed_input)
}
fn split_of(session: &Session) -> Split {
Split {
entered: session.entered(),
cache_read: session.cache_read(),
output: session.output_tokens(),
}
}
struct Sample {
last_turn: Option<u64>,
total: u64,
growth: u64,
split: Split,
span: u64,
active: u64,
turns: usize,
compact_at: Option<u64>,
compact_n: usize,
}
fn tp_from(s: Sample) -> Throughput {
Throughput {
last_turn: s.last_turn,
total: s.total,
growth: s.growth,
rates: rates_of(&s),
split: s.split,
turns: s.turns,
age_seconds: s.span,
active_seconds: s.active,
compact_at: s.compact_at,
compact_n: s.compact_n,
}
}
fn rates_of(s: &Sample) -> Rates {
Rates {
per_hour: rate_over(s.total, s.active, HOUR),
per_day: rate_over(s.total, s.active, DAY),
growth_hour: rate_over(s.growth, s.active, HOUR),
growth_day: rate_over(s.growth, s.active, DAY),
}
}
fn active_seconds(turns: &[crate::session::Turn]) -> u64 {
turns
.iter()
.zip(turns.iter().skip(1))
.map(|(a, b)| gap(&a.ts, &b.ts))
.fold(0u64, u64::saturating_add)
}
fn gap(before: &str, after: &str) -> u64 {
parse_ts(after)
.saturating_sub(parse_ts(before))
.min(IDLE_CAP)
}
const HOUR: u64 = 3_600;
const DAY: u64 = 86_400;
const IDLE_CAP: u64 = 300;
fn rate_over(total: u64, active: u64, period: u64) -> Option<u64> {
(active > 0).then(|| extrapolate(total, active, period))
}
fn extrapolate(total: u64, age: u64, period: u64) -> u64 {
total
.checked_mul(period)
.and_then(|v| v.checked_div(age))
.unwrap_or(0)
}
fn age_seconds(first: &str, last: &str) -> u64 {
parse_ts(last).saturating_sub(parse_ts(first))
}
fn parse_ts(ts: &str) -> u64 {
let days = days_from_civil(num(ts, 0..4), num(ts, 5..7), num(ts, 8..10));
let secs = num(ts, 11..13)
.saturating_mul(3600)
.saturating_add(num(ts, 14..16).saturating_mul(60))
.saturating_add(num(ts, 17..19));
days.saturating_mul(86_400).saturating_add(secs)
}
fn num(ts: &str, at: std::ops::Range<usize>) -> u64 {
ts.get(at).and_then(|s| s.parse().ok()).unwrap_or(0)
}
fn days_from_civil(y: u64, m: u64, d: u64) -> u64 {
let shifted = if m <= 2 { y.saturating_sub(1) } else { y };
let era = shifted.checked_div(400).unwrap_or(0);
let yoe = shifted.saturating_sub(era.saturating_mul(400));
era.saturating_mul(146_097)
.saturating_add(day_of_era(yoe, day_of_year(m, d)))
.saturating_sub(719_468)
}
fn day_of_year(m: u64, d: u64) -> u64 {
let mp = m.saturating_add(9).checked_rem(12).unwrap_or(0);
mp.saturating_mul(153)
.saturating_add(2)
.checked_div(5)
.unwrap_or(0)
.saturating_add(d)
.saturating_sub(1)
}
fn day_of_era(yoe: u64, doy: u64) -> u64 {
let leaps = yoe
.checked_div(4)
.unwrap_or(0)
.saturating_sub(yoe.checked_div(100).unwrap_or(0));
yoe.saturating_mul(365)
.saturating_add(leaps)
.saturating_add(doy)
}
pub(crate) fn shorten(n: u64) -> String {
if n <= 99 {
n.to_string()
} else if n <= 999_000 {
let k = n.saturating_add(999).checked_div(1000).unwrap_or(0);
format!("{k}k")
} else {
let m = n
.saturating_add(999_999)
.checked_div(1_000_000)
.unwrap_or(0);
format!("{m}m")
}
}
fn human(
tp: &Throughput,
config: &RateConfig,
color: bool,
gauge: Gauge,
) -> String {
let cells = cells_of(tp, config, gauge.limit);
let mut parts: Vec<String> =
cells.iter().map(|c| metric(*c, color)).collect();
parts.extend(gauge.eta.map(estimate));
format!("{}\n", parts.join(","))
}
fn estimate(seconds: u64) -> String {
format!("~{}", crate::eta::duration(seconds))
}
fn cells_of(
tp: &Throughput,
config: &RateConfig,
limit: Option<u64>,
) -> [Cell; 4] {
let age = tp.active_seconds;
let (hour, day) = (tp.rates.growth_hour, tp.rates.growth_day);
let gauge = tp
.last_turn
.map_or(Paint::None, |used| level(used, limit, config));
[
(tp.last_turn, "", "", gauge),
(Some(tp.total), "/bill", "", band(config.total)),
(hour, "/h", mark(age, HOUR), band(config.hour)),
(day, "/d", mark(age, DAY), band(config.day)),
]
}
fn level(used: u64, limit: Option<u64>, config: &RateConfig) -> Paint {
match limit.and_then(|l| crate::gauge::fill(used, l)) {
Some(f) => Paint::Fill(f),
None => band(config.turn),
}
}
fn band(threshold: Option<Threshold>) -> Paint {
threshold.map_or(Paint::None, Paint::Band)
}
fn mark(age: u64, period: u64) -> &'static str {
if age < period { "~" } else { "" }
}
type Cell = (Option<u64>, &'static str, &'static str, Paint);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Paint {
None,
Band(Threshold),
Fill(u64),
}
fn metric(cell: Cell, color: bool) -> String {
let (value, suffix, mark, paint) = cell;
let Some(value) = value else {
return format!("-{suffix}");
};
let alarm = match paint {
Paint::Fill(fill) => crate::gauge::alarm(fill),
_ => "",
};
let text = format!("{alarm}{mark}{}{suffix}", shorten(value));
colored(text, value, paint, color)
}
fn colored(text: String, value: u64, paint: Paint, color: bool) -> String {
if !color {
return text;
}
let code = match paint {
Paint::None => return text,
Paint::Band(th) => ansi_for(value, th).to_owned(),
Paint::Fill(fill) => {
crate::gauge::ansi(fill, crate::gauge::truecolor())
}
};
format!("{code}{text}\x1b[0m")
}
fn ansi_for(value: u64, th: Threshold) -> &'static str {
if value < th.green {
"\x1b[32m"
} else if value < th.amber {
"\x1b[33m"
} else {
"\x1b[31m"
}
}
fn or_null(v: Option<u64>) -> String {
v.map_or_else(|| "null".to_owned(), |n| n.to_string())
}
fn json(tp: &Throughput, eta: Option<u64>) -> String {
format!(
"{{\"last_turn\":{},\"total\":{},\"per_hour\":{},\
\"per_day\":{},\"turns\":{},{},{},\"compact_in_active_seconds\":{}}}\n",
or_null(tp.last_turn),
tp.total,
or_null(tp.rates.per_hour),
or_null(tp.rates.per_day),
tp.turns,
json_growth(tp),
json_clocks(tp),
or_null(eta),
)
}
fn json_growth(tp: &Throughput) -> String {
format!(
"\"growth\":{},\"growth_per_hour\":{},\"growth_per_day\":{},\
\"entered\":{},\"cache_read\":{},\"output\":{}",
tp.growth,
or_null(tp.rates.growth_hour),
or_null(tp.rates.growth_day),
or_null(tp.split.entered),
or_null(tp.split.cache_read),
or_null(tp.split.output),
)
}
fn json_clocks(tp: &Throughput) -> String {
format!(
"\"age_seconds\":{},\"active_seconds\":{},\
\"projected_hour\":{},\"projected_day\":{},\
\"compact_at\":{},\"compact_n\":{}",
tp.age_seconds,
tp.active_seconds,
tp.active_seconds < HOUR,
tp.active_seconds < DAY,
or_null(tp.compact_at),
tp.compact_n,
)
}
fn load_config(chdir: Option<&str>) -> RateConfig {
let Some(text) = read_config(chdir) else {
return RateConfig::default();
};
parse_config(&text)
}
fn parse_config(text: &str) -> RateConfig {
let Ok(config) = basic_toml::from_str::<TomlConfig>(text) else {
return RateConfig::default();
};
let Some(rate) = config.rate else {
return RateConfig::default();
};
config_from(rate)
}
fn config_from(rate: TomlRate) -> RateConfig {
RateConfig {
compact: rate.compact,
turn: rate.turn.map(to_threshold),
total: rate.total.map(to_threshold),
hour: rate.hour.map(to_threshold),
day: rate.day.map(to_threshold),
}
}
fn to_threshold(t: TomlThreshold) -> Threshold {
Threshold {
green: t.green,
amber: t.amber,
}
}
fn read_config(chdir: Option<&str>) -> Option<String> {
let start = PathBuf::from(chdir.unwrap_or("."));
if let Some(text) =
project_config(&start).and_then(|p| std::fs::read_to_string(p).ok())
{
return Some(text);
}
read_global_config()
}
fn project_config(start: &Path) -> Option<PathBuf> {
let start = std::fs::canonicalize(start).unwrap_or_else(|_| start.into());
let top = start.ancestors().find(|d| d.join(".git").exists());
let bound = top.unwrap_or(&start);
for dir in start.ancestors() {
let file = dir.join("itok.toml");
if file.is_file() {
return Some(file);
}
if dir == bound {
break;
}
}
None
}
fn read_global_config() -> Option<String> {
let home = std::env::var("HOME").ok()?;
let path = std::path::PathBuf::from(home).join(".config/itok/config.toml");
std::fs::read_to_string(path).ok()
}
fn is_tty() -> bool {
std::io::IsTerminal::is_terminal(&std::io::stdout())
}
fn parse(rest: &[String]) -> Result<Raw, String> {
let mut raw = Raw::default();
let mut it = rest.iter();
while let Some(a) = it.next() {
apply(a, &mut it, &mut raw)?;
}
Ok(raw)
}
fn apply<'a>(
a: &str,
it: &mut impl Iterator<Item = &'a String>,
raw: &mut Raw,
) -> Result<(), String> {
match a {
"--bpe" | "--ollama" => {
return Err(crate::tracecmd::no_real_tier(a, "rate"));
}
"--color" => raw.color = Some(parse_color(&value(it, a)?)?),
"--format" => raw.format = crate::tracecmd::format_of(&value(it, a)?)?,
"-C" => raw.chdir = Some(value(it, a)?),
"--statusline" => raw.statusline = true,
_ => return apply_positional(a, raw),
}
Ok(())
}
fn parse_color(s: &str) -> Result<ColorMode, String> {
match s {
"auto" => Ok(ColorMode::Auto),
"always" => Ok(ColorMode::Always),
"never" => Ok(ColorMode::Never),
other => Err(format!("unknown color mode '{other}'")),
}
}
fn apply_positional(a: &str, raw: &mut Raw) -> Result<(), String> {
if a.starts_with('-') {
return Err(format!("unknown flag {a}"));
}
raw.session = Some(a.to_owned());
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::session::Turn;
const ZERO_RATES: Rates = Rates {
per_hour: Some(0),
per_day: Some(0),
growth_hour: Some(0),
growth_day: Some(0),
};
const ZERO_SPLIT: Split = Split {
entered: None,
cache_read: None,
output: None,
};
const ZERO_TP: Throughput = Throughput {
last_turn: Some(0),
total: 0,
growth: 0,
rates: ZERO_RATES,
split: ZERO_SPLIT,
turns: 0,
age_seconds: 0,
active_seconds: 0,
compact_at: None,
compact_n: 0,
};
#[test]
fn shorten_raw_digits_below_100() {
assert_eq!(shorten(0), "0");
assert_eq!(shorten(42), "42");
assert_eq!(shorten(99), "99");
}
#[test]
fn shorten_ceiling_k_small() {
assert_eq!(shorten(100), "1k");
assert_eq!(shorten(900), "1k");
assert_eq!(shorten(1_000), "1k");
assert_eq!(shorten(1_001), "2k");
assert_eq!(shorten(1_500), "2k");
}
#[test]
fn shorten_ceiling_k_large() {
assert_eq!(shorten(47_000), "47k");
assert_eq!(shorten(120_000), "120k");
assert_eq!(shorten(900_000), "900k");
assert_eq!(shorten(999_000), "999k");
}
#[test]
fn shorten_ceiling_m_range() {
assert_eq!(shorten(999_001), "1m");
assert_eq!(shorten(1_000_000), "1m");
assert_eq!(shorten(1_500_000), "2m");
assert_eq!(shorten(22_000_000), "22m");
}
#[test]
fn shorten_never_produces_1000k() {
for n in [999_000, 999_001, 999_499, 999_500, 1_000_000] {
let s = shorten(n);
assert!(!s.contains("1000k"), "{n} -> {s}");
}
}
fn session_with_turns(inputs: &[(u64, &str)]) -> Session {
let mut s = Session::default();
for (input, ts) in inputs {
s.turns.push(Turn {
input: Some(*input),
ts: (*ts).to_owned(),
..Turn::default()
});
}
s
}
const T0: &str = "2026-08-15T06:00:00.000Z";
const T1H: &str = "2026-08-15T07:00:00.000Z";
#[test]
fn json_answers_a_short_session_with_an_object() {
let one = session_with_turns(&[(1_111, "2026-08-22T10:00:00.000Z")]);
let raw = Raw {
format: Format::Json,
..Raw::default()
};
let out = too_few(&raw, &one, &[]).out;
assert!(out.starts_with('{'), "one object, not silence: {out}");
assert!(out.contains("\"turns\":1"), "{out}");
assert!(out.contains("\"last_turn\":1111"), "{out}");
assert!(out.contains("\"total\":1111"), "{out}");
assert!(out.contains("\"per_hour\":null"), "{out}");
assert!(out.contains("\"per_day\":null"), "{out}");
}
#[test]
fn the_badge_stays_hidden_on_a_short_session() {
let one = session_with_turns(&[(1_111, "2026-08-22T10:00:00.000Z")]);
let out = too_few(&Raw::default(), &one, &[]).out;
assert!(out.is_empty(), "badge hides: {out}");
}
#[test]
fn throughput_needs_at_least_two_turns() {
let s = session_with_turns(&[(1000, T0)]);
assert!(throughput(&s, &[]).is_none());
let empty = Session::default();
assert!(throughput(&empty, &[]).is_none());
}
#[test]
fn throughput_computes_totals() {
let s = session_with_turns(&[(1_000, T0), (2_000, T1H)]);
let tp = throughput(&s, &[]);
assert!(tp.is_some());
let tp = tp.unwrap_or(ZERO_TP);
assert_eq!(tp.last_turn, Some(2_000));
assert_eq!(tp.total, 3_000);
assert_eq!(tp.turns, 2);
}
#[test]
fn rates_divide_by_active_time_not_span() {
let s = session_with_turns(&[(1_000, T0), (2_000, T1H)]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.age_seconds, 3600, "span still reported");
assert_eq!(tp.active_seconds, IDLE_CAP, "the gap is capped");
assert_eq!(tp.rates.per_hour, Some(36_000));
assert_eq!(tp.rates.per_day, Some(864_000));
}
#[test]
fn each_gap_is_capped_on_its_own() {
let turns = session_with_turns(&[
(1, "2026-08-15T06:00:00.000Z"),
(1, "2026-08-15T06:00:30.000Z"),
(1, "2026-08-15T06:02:00.000Z"),
(1, "2026-08-16T06:02:00.000Z"),
(1, "2026-08-16T06:03:00.000Z"),
]);
let active = active_seconds(&turns.turns);
assert_eq!(active, 30 + 90 + IDLE_CAP + 60);
}
#[test]
fn an_absence_is_truncated_not_counted() {
let s = session_with_turns(&[
(1_000, "2026-08-15T06:00:00.000Z"),
(2_000, "2026-08-18T06:00:00.000Z"),
]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.age_seconds, 3 * 86_400, "three days of span");
assert_eq!(tp.active_seconds, IDLE_CAP, "five minutes of work");
}
#[test]
fn an_unreadable_clock_leaves_no_active_time() {
let s = session_with_turns(&[(1_000, "nope"), (2_000, "also-nope")]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.active_seconds, 0);
assert_eq!(tp.rates.per_hour, None, "no working time, no rate");
assert_eq!(tp.rates.per_day, None);
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert!(out.contains("-/h") && out.contains("-/d"), "{out}");
assert!(!out.contains('~'), "nothing to project from: {out}");
}
#[test]
fn a_clockless_rate_never_publishes_an_amplified_number() {
let s = session_with_turns(&[(1_000, "nope"), (2_000, "also-nope")]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert!(!out.contains('m'), "no megatoken rate anywhere: {out}");
let js = json(&tp, None);
assert!(js.contains("\"per_hour\":null"), "{js}");
assert!(js.contains("\"per_day\":null"), "{js}");
assert!(js.contains("\"active_seconds\":0"), "{js}");
}
#[test]
fn two_turns_in_one_second_publish_no_rate() {
let s = session_with_turns(&[
(52, "2026-08-22T10:00:00.100Z"),
(52, "2026-08-22T10:00:00.900Z"),
]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.active_seconds, 0, "same second, no gap credited");
assert_eq!(tp.total, 104);
assert_eq!(tp.rates.per_hour, None, "104 tokens are not 375k/h");
assert_eq!(tp.rates.per_day, None);
}
#[test]
fn rfc3339_stamps_become_epoch_seconds() {
assert_eq!(parse_ts("1970-01-01T00:00:00.000Z"), 0);
assert_eq!(parse_ts("1970-01-02T00:00:01.000Z"), 86_401);
assert_eq!(parse_ts("2000-03-01T00:00:00.000Z"), 951_868_800);
assert_eq!(parse_ts("2026-08-15T06:55:39.102Z"), 1_786_776_939);
}
#[test]
fn leap_days_are_counted() {
let day = parse_ts("2024-03-01T00:00:00.000Z")
.saturating_sub(parse_ts("2024-02-29T00:00:00.000Z"));
assert_eq!(day, 86_400, "2024-02-29 exists");
let century = parse_ts("2100-03-01T00:00:00.000Z")
.saturating_sub(parse_ts("2100-02-28T00:00:00.000Z"));
assert_eq!(century, 86_400, "2100 is not a leap year");
}
#[test]
fn an_unreadable_stamp_is_no_age() {
assert_eq!(parse_ts(""), 0);
assert_eq!(parse_ts("not-a-timestamp"), 0);
assert_eq!(parse_ts("1000000000"), 0);
let pre = parse_ts("1900-06-01T12:00:00.000Z");
assert!(pre < 86_400, "pre-epoch clamps to the epoch day: {pre}");
}
#[test]
fn human_output_shape() {
let out = human(
&sample_tp(),
&RateConfig::default(),
false,
Gauge::default(),
);
assert_eq!(out, "3k,46k/bill,~13k/h,~280k/d\n");
}
#[test]
fn mark_flips_at_the_period_it_names() {
assert_eq!(mark(3599, HOUR), "~");
assert_eq!(mark(3600, HOUR), "");
assert_eq!(mark(86_399, DAY), "~");
assert_eq!(mark(86_400, DAY), "");
}
#[test]
fn a_covered_period_drops_its_mark() {
let tp = Throughput {
active_seconds: 7_200,
..sample_tp()
};
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert_eq!(out, "3k,46k/bill,13k/h,~280k/d\n");
}
#[test]
fn a_day_long_sample_marks_nothing() {
let tp = Throughput {
active_seconds: 90_000,
..sample_tp()
};
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert_eq!(out, "3k,46k/bill,13k/h,280k/d\n");
}
#[test]
fn a_marked_value_keeps_its_color() {
let config = RateConfig {
hour: Some(Threshold {
green: 1_000,
amber: 100_000,
}),
..RateConfig::default()
};
let out = human(&sample_tp(), &config, true, Gauge::default());
assert!(out.contains("\x1b[33m~13k/h\x1b[0m"), "{out}");
}
#[test]
fn a_level_with_a_limit_is_painted_by_the_gauge() {
let config = RateConfig {
turn: Some(Threshold {
green: 50_000,
amber: 100_000,
}),
..RateConfig::default()
};
let tp = Throughput {
last_turn: Some(963_000),
..sample_tp()
};
let out = human(&tp, &config, true, gauge_at(1_000_000));
assert!(!out.contains("\x1b[32m963k"), "band colour won: {out}");
assert!(out.contains("!963k"), "alarm mark missing: {out}");
}
#[test]
fn a_level_without_a_limit_falls_back_to_the_declared_band() {
let config = RateConfig {
turn: Some(Threshold {
green: 50_000,
amber: 100_000,
}),
..RateConfig::default()
};
let tp = Throughput {
last_turn: Some(963_000),
..sample_tp()
};
let out = human(&tp, &config, true, Gauge::default());
assert!(out.contains("\x1b[31m963k\x1b[0m"), "{out}");
}
#[test]
fn a_zero_level_is_never_painted_green_by_the_gauge() {
let tp = Throughput {
last_turn: Some(0),
..sample_tp()
};
let out = human(&tp, &RateConfig::default(), true, gauge_at(1_000_000));
assert!(!out.contains("\x1b["), "absent level took a colour: {out}");
}
#[test]
fn no_limit_and_no_threshold_leaves_the_level_plain() {
let out =
human(&sample_tp(), &RateConfig::default(), true, Gauge::default());
assert!(!out.contains("\x1b["), "{out}");
}
#[test]
fn a_declared_compaction_point_wins_over_the_observed_one() {
let raw = Raw::default();
let tp = Throughput {
compact_at: Some(900_000),
..sample_tp()
};
let config = RateConfig {
compact: Some(Compact::Every(750_000)),
..RateConfig::default()
};
assert_eq!(red_line(&raw, &tp, &config), Some(750_000));
assert_eq!(
red_line(&raw, &tp, &RateConfig::default()),
Some(900_000),
"the session's own record is the next rung"
);
}
#[test]
fn a_per_model_table_answers_for_the_models_it_lists() {
let text = "[rate.compact]\n\
\"claude-opus-5\" = 968887\n\
\"claude-opus-4-6\" = 167028\n";
let parsed: TomlConfig = basic_toml::from_str(text).unwrap_or_default();
let compact = config_from(parsed.rate.unwrap_or_default()).compact;
let compact = compact.unwrap_or(Compact::Every(0));
assert_eq!(compact.point(Some("claude-opus-5")), Some(968_887));
assert_eq!(compact.point(Some("claude-opus-4-6")), Some(167_028));
}
#[test]
fn an_unlisted_model_gets_no_opinion_from_the_table() {
let mut table = std::collections::BTreeMap::new();
table.insert("claude-opus-5".to_owned(), 968_887);
let compact = Compact::PerModel(table);
assert_eq!(compact.point(Some("claude-opus-4-6")), None);
assert_eq!(compact.point(None), None, "no model named at all");
}
#[test]
fn a_variant_suffix_falls_back_to_the_base_id() {
let mut table = std::collections::BTreeMap::new();
table.insert("claude-opus-5".to_owned(), 968_887);
let compact = Compact::PerModel(table);
assert_eq!(compact.point(Some("claude-opus-5[1m]")), Some(968_887));
}
#[test]
fn an_entry_for_the_variant_beats_the_base_entry() {
let mut table = std::collections::BTreeMap::new();
table.insert("claude-opus-5".to_owned(), 168_000);
table.insert("claude-opus-5[1m]".to_owned(), 968_887);
let compact = Compact::PerModel(table);
assert_eq!(compact.point(Some("claude-opus-5[1m]")), Some(968_887));
assert_eq!(compact.point(Some("claude-opus-5")), Some(168_000));
}
#[test]
fn a_variant_of_an_unlisted_model_still_gets_no_opinion() {
let mut table = std::collections::BTreeMap::new();
table.insert("claude-opus-5".to_owned(), 968_887);
let compact = Compact::PerModel(table);
assert_eq!(compact.point(Some("claude-opus-4-6[1m]")), None);
}
#[test]
fn the_scalar_form_answers_for_every_model() {
let compact = Compact::Every(968_887);
assert_eq!(compact.point(Some("anything")), Some(968_887));
assert_eq!(compact.point(None), Some(968_887));
}
#[test]
fn an_unlisted_model_falls_through_to_the_sessions_own_record() {
let mut table = std::collections::BTreeMap::new();
table.insert("claude-opus-5".to_owned(), 968_887);
let config = RateConfig {
compact: Some(Compact::PerModel(table)),
..RateConfig::default()
};
let raw = Raw {
model: Some("claude-opus-4-6".to_owned()),
..Raw::default()
};
let tp = Throughput {
compact_at: Some(167_028),
..sample_tp()
};
assert_eq!(red_line(&raw, &tp, &config), Some(167_028));
}
#[test]
fn no_observation_and_no_table_leaves_no_red_line() {
let raw = Raw::default();
assert_eq!(red_line(&raw, &sample_tp(), &RateConfig::default()), None);
}
#[test]
fn json_carries_the_compaction_point_and_its_n() {
let tp = Throughput {
compact_at: Some(968_887),
compact_n: 2,
..sample_tp()
};
let js = json(&tp, None);
assert!(js.contains("\"compact_at\":968887"), "{js}");
assert!(js.contains("\"compact_n\":2"), "{js}");
}
#[test]
fn an_unobserved_compaction_point_is_null_in_json() {
let js = json(&sample_tp(), None);
assert!(js.contains("\"compact_at\":null"), "{js}");
assert!(js.contains("\"compact_n\":0"), "{js}");
}
#[test]
fn toml_carries_a_compaction_point() {
let text = "[rate]\ncompact = 968887\n";
let parsed: TomlConfig = basic_toml::from_str(text).unwrap_or_default();
let rate = parsed.rate.unwrap_or_default();
let got = config_from(rate).compact;
assert_eq!(got.and_then(|c| c.point(None)), Some(968_887));
}
#[test]
fn a_flat_window_publishes_no_growth_however_long_it_runs() {
let flat = session_with_turns(&[
(500_000, T0),
(500_000, "2026-08-15T06:01:00.000Z"),
(500_000, "2026-08-15T06:02:00.000Z"),
]);
let tp = throughput(&flat, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.growth, 500_000, "only the entry window entered");
assert_eq!(tp.total, 1_500_000, "the bill counted every re-send");
let hour = tp.rates.growth_hour.unwrap_or(0);
let billed = tp.rates.per_hour.unwrap_or(0);
assert_eq!(billed, hour.saturating_mul(3), "the bill runs 3x here");
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert!(out.contains(&format!("{}/h", shorten(hour))), "{out}");
assert!(!out.contains(&format!("{}/h", shorten(billed))), "{out}");
}
#[test]
fn a_growing_window_publishes_what_it_added() {
let rising = session_with_turns(&[
(100_000, T0),
(400_000, "2026-08-15T06:01:00.000Z"),
]);
let tp = throughput(&rising, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.growth, 400_000, "the window it reached");
assert_eq!(tp.total, 500_000, "what it was billed on the way");
let out = human(&tp, &RateConfig::default(), false, Gauge::default());
assert!(out.contains("500k/bill"), "{out}");
}
#[test]
fn json_keeps_the_old_keys_at_their_old_meaning() {
let js = json(&sample_tp(), None);
assert!(js.contains("\"total\":45305"), "{js}");
assert!(js.contains("\"per_hour\":12400"), "{js}");
assert!(js.contains("\"per_day\":280000"), "{js}");
}
#[test]
fn json_names_growth_and_the_bills_composition() {
let js = json(&sample_tp(), None);
assert!(js.contains("\"growth\":6000"), "{js}");
assert!(js.contains("\"growth_per_hour\":13000"), "{js}");
assert!(js.contains("\"entered\":9000"), "{js}");
assert!(js.contains("\"cache_read\":36000"), "{js}");
assert!(js.contains("\"output\":1200"), "{js}");
}
#[test]
fn an_unreported_split_field_is_null_rather_than_zero() {
let tp = Throughput {
split: Split::default(),
..sample_tp()
};
let js = json(&tp, None);
assert!(js.contains("\"entered\":null"), "{js}");
assert!(js.contains("\"output\":null"), "{js}");
}
const SAMPLE_RATES: Rates = Rates {
per_hour: Some(12_400),
per_day: Some(280_000),
growth_hour: Some(13_000),
growth_day: Some(280_000),
};
const SAMPLE_SPLIT: Split = Split {
entered: Some(9_000),
cache_read: Some(36_000),
output: Some(1_200),
};
#[test]
fn the_badge_grows_a_fifth_cell_when_the_gauge_can_date_it() {
let g = Gauge {
limit: Some(1_000_000),
eta: Some(5_400),
};
let out = human(&sample_tp(), &RateConfig::default(), false, g);
assert!(out.ends_with("~1h\n"), "floored to the hour: {out}");
assert_eq!(out.matches(',').count(), 4, "five cells: {out}");
}
#[test]
fn the_badge_stays_four_cells_without_a_red_line() {
let out = human(
&sample_tp(),
&RateConfig::default(),
false,
Gauge::default(),
);
assert_eq!(out.matches(',').count(), 3, "four cells: {out}");
assert!(!out.contains('~') || out.contains("/h"), "{out}");
}
#[test]
fn the_gauge_dates_the_red_line_from_the_growth_rate() {
let config = RateConfig {
compact: Some(Compact::Every(1_000_000)),
..RateConfig::default()
};
let tp = Throughput {
last_turn: Some(900_000),
..sample_tp()
};
let g = gauge_of(&Raw::default(), &tp, &config);
assert_eq!(g.limit, Some(1_000_000));
assert_eq!(g.eta, Some(27_692), "100k left at 13k per active hour");
}
#[test]
fn json_always_carries_the_estimate_key() {
let with = json(&sample_tp(), Some(3_600));
assert!(
with.contains("\"compact_in_active_seconds\":3600"),
"{with}"
);
let without = json(&sample_tp(), None);
assert!(
without.contains("\"compact_in_active_seconds\":null"),
"{without}"
);
}
fn gauge_at(limit: u64) -> Gauge {
Gauge {
limit: Some(limit),
eta: None,
}
}
fn json_of(tp: Throughput) -> String {
json(&tp, None)
}
fn sample_tp() -> Throughput {
Throughput {
last_turn: Some(2_117),
total: 45_305,
growth: 6_000,
rates: SAMPLE_RATES,
split: SAMPLE_SPLIT,
turns: 22,
age_seconds: 3120,
active_seconds: 3120,
compact_at: None,
compact_n: 0,
}
}
#[test]
fn json_is_one_line() {
let out = json(&sample_tp(), None);
assert_eq!(out.lines().count(), 1);
assert!(!out.contains('~'), "no tilde in json (V9)");
}
#[test]
fn json_carries_all_fields() {
let out = json(&sample_tp(), None);
assert!(out.contains("\"last_turn\":2117"));
assert!(out.contains("\"total\":45305"));
assert!(out.contains("\"per_hour\":12400"));
assert!(out.contains("\"per_day\":280000"));
}
#[test]
fn an_absent_last_turn_is_a_dash_not_a_zero() {
let mut s = session_with_turns(&[(1_000, T0)]);
s.turns.push(Turn {
ts: T1H.to_owned(),
..Turn::default()
});
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.last_turn, None);
let cfg = RateConfig::default();
let out = human(&tp, &cfg, false, Gauge::default());
assert!(out.starts_with("-,"), "{out}");
assert!(json_of(tp).contains("\"last_turn\":null"));
}
#[test]
fn a_last_turn_that_billed_zero_still_reads_zero() {
let s = session_with_turns(&[(1_000, T0), (0, T1H)]);
let tp = throughput(&s, &[]).unwrap_or(ZERO_TP);
assert_eq!(tp.last_turn, Some(0));
let cfg = RateConfig::default();
let out = human(&tp, &cfg, false, Gauge::default());
assert!(out.starts_with("0,"), "{out}");
assert!(json_of(tp).contains("\"last_turn\":0,"));
}
#[test]
fn json_flags_each_projection() {
let short = json(&sample_tp(), None);
assert!(short.contains("\"projected_hour\":true"), "{short}");
assert!(short.contains("\"projected_day\":true"), "{short}");
let long = json_of(Throughput {
active_seconds: 90_000,
..sample_tp()
});
assert!(long.contains("\"projected_hour\":false"), "{long}");
assert!(long.contains("\"projected_day\":false"), "{long}");
}
#[test]
fn color_applied_when_threshold_present() {
let th = Some(Threshold {
green: 50_000,
amber: 100_000,
});
let green = colored("1k".to_owned(), 1_000, band(th), true);
assert!(green.contains("\x1b[32m"), "green: {green}");
let amber = colored("60k".to_owned(), 60_000, band(th), true);
assert!(amber.contains("\x1b[33m"), "amber: {amber}");
let red = colored("120k".to_owned(), 120_000, band(th), true);
assert!(red.contains("\x1b[31m"), "red: {red}");
}
#[test]
fn color_absent_without_threshold() {
let out = colored("1k".to_owned(), 1_000, Paint::None, true);
assert!(!out.contains('\x1b'), "no ANSI without threshold");
}
#[test]
fn auto_reads_the_stream_the_badge_is_written_to() {
let piped = !std::io::IsTerminal::is_terminal(&std::io::stdout());
assert!(piped, "the harness captures stdout");
assert!(!want_color(ColorMode::Auto), "no escapes into a pipe");
assert!(want_color(ColorMode::Always));
assert!(!want_color(ColorMode::Never));
}
#[test]
fn color_absent_when_disabled() {
let th = Some(Threshold {
green: 50_000,
amber: 100_000,
});
let out = colored("1k".to_owned(), 1_000, band(th), false);
assert!(!out.contains('\x1b'), "no ANSI when color=false");
}
#[test]
fn toml_config_parses() {
let text = r#"
[rate]
turn = { green = 50000, amber = 100000 }
total = { green = 1000000, amber = 5000000 }
"#;
let parsed: TomlConfig = basic_toml::from_str(text).unwrap_or_default();
let rate = parsed.rate.unwrap_or_default();
assert_eq!(rate.turn.as_ref().map(|t| t.green), Some(50000));
assert_eq!(rate.turn.as_ref().map(|t| t.amber), Some(100000));
assert_eq!(rate.total.as_ref().map(|t| t.green), Some(1000000));
assert!(rate.hour.is_none());
}
#[test]
fn malformed_toml_degrades_silently() {
let text = "this is not valid toml [[[";
let parsed: Result<TomlConfig, _> = basic_toml::from_str(text);
assert!(parsed.is_err());
}
#[test]
fn a_one_turn_transcript_answers_in_both_formats() {
let path = fixture("minimal.jsonl");
let human = super::rate(std::slice::from_ref(&path), ¬hing);
assert!(human.out.is_empty(), "badge hides: {:?}", human.out);
assert_eq!(human.code, 0);
let js = super::rate(
&[path, "--format".to_owned(), "json".to_owned()],
¬hing,
);
assert!(js.out.starts_with('{'), "one object: {:?}", js.out);
assert!(js.out.contains("\"per_hour\":null"), "{}", js.out);
}
#[test]
fn a_broken_or_rateless_config_degrades_to_the_default() {
let broken = parse_config("[rate\nturn = oops");
assert!(broken.turn.is_none() && broken.hour.is_none());
let rateless = parse_config("[limits]\nsrc = 1000\n");
assert!(rateless.turn.is_none() && rateless.day.is_none());
}
fn planted(name: &str, dirs: &[&str], files: &[&str]) -> PathBuf {
let root = std::env::temp_dir().join(format!("itok-cfg-{name}"));
let _ = std::fs::remove_dir_all(&root);
for d in dirs {
let _ = std::fs::create_dir_all(root.join(d));
}
for f in files {
let _ = std::fs::write(root.join(f), "[rate]\n");
}
std::fs::canonicalize(&root).unwrap_or(root)
}
#[test]
fn config_is_found_above_a_subdirectory_up_to_the_git_root() {
let root =
planted("up", &["repo/.git", "repo/a/b"], &["repo/itok.toml"]);
let found = project_config(&root.join("repo/a/b"));
assert_eq!(found, Some(root.join("repo/itok.toml")));
}
#[test]
fn the_nearest_config_wins() {
let root = planted(
"near",
&["repo/.git", "repo/a/b"],
&["repo/itok.toml", "repo/a/itok.toml"],
);
let found = project_config(&root.join("repo/a/b"));
assert_eq!(found, Some(root.join("repo/a/itok.toml")));
}
#[test]
fn the_search_never_crosses_the_git_root() {
let root = planted(
"bound",
&["outer/inner/.git", "outer/inner/a"],
&["outer/itok.toml"],
);
assert_eq!(project_config(&root.join("outer/inner/a")), None);
}
#[test]
fn outside_a_repository_only_the_directory_itself_is_read() {
let root = planted("norepo", &["top/a"], &["top/itok.toml"]);
assert_eq!(project_config(&root.join("top/a")), None);
let here = project_config(&root.join("top"));
assert_eq!(here, Some(root.join("top/itok.toml")));
}
#[test]
fn tier_flags_are_rejected_by_name() {
for flag in ["--bpe", "--ollama"] {
let out = super::rate(&[flag.to_owned()], ¬hing);
assert_eq!(out.code, 2, "{flag} is a usage error");
assert!(out.err.contains("rate"), "names the verb: {}", out.err);
}
}
fn fixture(name: &str) -> String {
format!(
"{}/tests/fixtures/session/{name}",
env!("CARGO_MANIFEST_DIR")
)
}
fn nothing() -> String {
String::new()
}
fn rate(args: &[String]) -> Output {
super::rate(args, ¬hing)
}
fn payload(transcript: &str, cwd: &str) -> String {
format!(
"{{\"session_id\":\"s1\",\"transcript_path\":\"{transcript}\",\
\"cwd\":\"{cwd}\",\"model\":{{\"id\":\"claude\"}}}}"
)
}
#[test]
fn statusline_reads_the_transcript_from_the_payload() {
let text = payload(&fixture("tool-shapes.jsonl"), "/tmp");
let src = || text.clone();
let out = super::rate(&["--statusline".to_owned()], &src);
assert_eq!(out.code, 0);
assert!(out.out.starts_with("(itok:"), "wrapped: {:?}", out.out);
assert!(out.out.ends_with(')'), "wrapped: {:?}", out.out);
}
#[test]
fn statusline_colors_by_default() {
let dir = std::env::temp_dir().join("itok-rate-statusline");
let _ = std::fs::create_dir_all(&dir);
let _ = std::fs::write(
dir.join("itok.toml"),
"[rate]\nturn = { green = 1, amber = 2 }\n",
);
let text =
payload(&fixture("tool-shapes.jsonl"), &dir.display().to_string());
let src = || text.clone();
let out = super::rate(&["--statusline".to_owned()], &src);
assert!(out.out.contains('\x1b'), "ANSI by default: {:?}", out.out);
}
#[test]
fn an_explicit_color_beats_the_statusline_default() {
let text = payload(&fixture("tool-shapes.jsonl"), "/tmp");
let src = || text.clone();
let args = ["--statusline", "--color", "never"];
let out = super::rate(
&args.iter().map(|s| (*s).to_owned()).collect::<Vec<_>>(),
&src,
);
assert!(!out.out.contains('\x1b'), "explicit never: {:?}", out.out);
}
#[test]
fn a_payload_without_a_transcript_is_a_usage_error() {
let src = || "{\"session_id\":\"s1\"}".to_owned();
let out = super::rate(&["--statusline".to_owned()], &src);
assert_eq!(out.code, 2);
assert!(out.err.contains("transcript_path"), "{:?}", out.err);
assert!(out.out.is_empty(), "statusline renders nothing");
}
#[test]
fn stdin_is_read_only_under_the_flag() {
let seen = std::cell::Cell::new(false);
let src = || {
seen.set(true);
String::new()
};
let _ = super::rate(&[fixture("tool-shapes.jsonl")], &src);
assert!(!seen.get(), "bare rate must not read stdin");
let _ = super::rate(&["--statusline".to_owned()], &src);
assert!(seen.get(), "--statusline must read stdin");
}
#[test]
fn an_empty_rate_produces_no_badge() {
assert_eq!(badge(String::new()), "");
assert_eq!(badge("\n".to_owned()), "");
assert_eq!(badge("1k,2k/total\n".to_owned()), "(itok:1k,2k/total)");
}
#[test]
fn rate_on_fixture_exits_zero() {
let out = rate(&[fixture("tool-shapes.jsonl")]);
assert_eq!(out.code, 0, "report-only (V5)");
}
#[test]
fn rate_json_on_fixture() {
let out = rate(&[
fixture("tool-shapes.jsonl"),
"--format".to_owned(),
"json".to_owned(),
]);
assert_eq!(out.code, 0);
assert!(out.out.contains("\"last_turn\":"));
assert!(out.out.contains("\"turns\":"));
}
#[test]
fn rate_with_color_never() {
let out = rate(&[
fixture("tool-shapes.jsonl"),
"--color".to_owned(),
"never".to_owned(),
]);
assert_eq!(out.code, 0);
assert!(!out.out.contains('\x1b'), "no ANSI with --color never");
}
#[test]
fn a_named_miss_is_a_usage_error() {
let out = rate(&["/nonexistent/s.jsonl".to_owned()]);
assert_eq!(out.code, 2);
}
#[test]
fn unknown_flags_are_usage_errors() {
assert_eq!(rate(&["--nope".to_owned()]).code, 2);
assert_eq!(rate(&["--color".to_owned(), "rainbow".to_owned()]).code, 2);
assert_eq!(rate(&["--format".to_owned(), "yaml".to_owned()]).code, 2);
}
#[test]
fn json_carries_both_clocks() {
let out = json_of(Throughput {
age_seconds: 300_000,
active_seconds: 3_120,
..sample_tp()
});
assert!(out.contains("\"age_seconds\":300000"), "{out}");
assert!(out.contains("\"active_seconds\":3120"), "{out}");
}
}