use std::io::Write;
use std::process::{Command, Stdio};
fn bin() -> &'static str {
env!("CARGO_BIN_EXE_tztr")
}
fn temp_path(stem: &str) -> std::path::PathBuf {
std::env::temp_dir().join(format!("{stem}-{}.log", std::process::id()))
}
struct Output {
stdout: Vec<u8>,
stderr: String,
ok: bool,
}
impl Output {
fn out(&self) -> &str {
std::str::from_utf8(&self.stdout).expect("stdout is utf-8")
}
}
fn run_tz(input: &[u8], args: &[&str], tz: Option<&str>) -> Output {
let mut cmd = Command::new(bin());
cmd.args(args);
match tz {
Some(tz) => cmd.env("TZ", tz),
None => cmd.env_remove("TZ"),
};
let mut child = cmd
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
let mut stdin = child.stdin.take().unwrap();
if let Err(e) = stdin.write_all(input) {
assert_eq!(
e.kind(),
std::io::ErrorKind::BrokenPipe,
"writing stdin: {e}"
);
}
drop(stdin);
let out = child.wait_with_output().unwrap();
Output {
stdout: out.stdout,
stderr: String::from_utf8_lossy(&out.stderr).into_owned(),
ok: out.status.success(),
}
}
fn run(input: &str, args: &[&str], tz: &str) -> (String, bool) {
let o = run_tz(input.as_bytes(), args, Some(tz));
(o.out().to_string(), o.ok)
}
fn stdout(input: &str, args: &[&str]) -> String {
let (o, ok) = run(input, args, "UTC");
assert!(ok, "expected success");
o.trim_end().to_string()
}
fn fails(input: &str, args: &[&str]) -> String {
let o = run_tz(input.as_bytes(), args, Some("UTC"));
assert!(!o.ok, "expected failure, got stdout {:?}", o.out());
assert!(o.stdout.is_empty(), "expected no stdout: {:?}", o.out());
o.stderr.trim_end_matches('\n').to_string()
}
#[test]
fn converts_via_stdin() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "America/Los_Angeles"]),
"2026-04-03T05:00:00-07:00"
);
}
#[test]
fn handles_multiline_input() {
let out = stdout(
"first 2026-04-03T12:00:00Z\nsecond 2026-04-03T13:00:00Z\n",
&["-t", "America/Los_Angeles"],
);
let lines: Vec<&str> = out.lines().collect();
assert_eq!(lines[0], "first 2026-04-03T05:00:00-07:00");
assert_eq!(lines[1], "second 2026-04-03T06:00:00-07:00");
}
#[test]
fn uses_tz_env_as_default_output() {
let (o, ok) = run("2026-04-03T12:00:00Z\n", &[], "America/New_York");
assert!(ok);
assert_eq!(o.trim_end(), "2026-04-03T08:00:00-04:00");
}
#[test]
fn accepts_alias_and_numeric_offset() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "sf"]),
"2026-04-03T05:00:00-07:00"
);
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "-7"]),
"2026-04-03T05:00:00-07:00"
);
}
#[test]
fn shows_version() {
assert_eq!(stdout("", &["-V"]), env!("CARGO_PKG_VERSION"));
}
#[test]
fn shows_help() {
let out = stdout("", &["-h"]);
assert!(out.contains("Usage: tztr"));
assert!(out.contains("Timezone Translator"));
}
#[test]
fn bundles_short_flags() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-tsf"]),
"2026-04-03T05:00:00-07:00"
);
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-vtsf"]),
"2026-04-03T05:00:00-07:00"
);
let help = stdout("", &["-hj"]);
assert!(serde_json::from_str::<serde_json::Value>(&help).is_ok());
}
#[test]
fn shows_help_as_json() {
let out = stdout("", &["-h", "-j"]);
let doc: serde_json::Value = serde_json::from_str(&out).unwrap();
assert_eq!(doc["name"], "tztr");
assert_eq!(doc["version"], env!("CARGO_PKG_VERSION"));
let opts = doc["options"].as_array().unwrap();
assert!(opts.iter().any(|o| o["long"] == "--from"));
assert!(opts.iter().any(|o| o["long"] == "--detect"));
let text = stdout("", &["-h"]);
for o in opts {
let long = o["long"].as_str().unwrap();
assert!(text.contains(long), "text help missing {long}");
}
let nd = stdout("", &["-h", "-J"]);
assert_eq!(nd.lines().count(), 1);
let nd_doc: serde_json::Value = serde_json::from_str(&nd).unwrap();
assert_eq!(nd_doc, doc);
}
#[test]
fn lists_aliases() {
let out = stdout("", &["-l"]);
assert!(out.contains("sf"));
assert!(out.contains("America/Los_Angeles"));
}
#[test]
fn emits_json_array() {
let out = stdout("from 15:30 UTC to 16:45 UTC", &["-t", "pst", "-j"]);
let v: serde_json::Value = serde_json::from_str(&out).unwrap();
assert_eq!(v[0]["translated"], "08:30 PDT");
assert_eq!(v[1]["translated"], "09:45 PDT");
assert_eq!(v[0]["detected_tz"], "UTC");
}
#[test]
fn emits_ndjson() {
let out = stdout(
"2026-04-03T12:00:00Z\n2026-04-03T13:00:00Z\n",
&["-t", "pst", "-J"],
);
let converted: Vec<String> = out
.lines()
.map(|l| {
serde_json::from_str::<serde_json::Value>(l).unwrap()["translated"]
.as_str()
.unwrap()
.to_string()
})
.collect();
assert_eq!(
converted,
vec!["2026-04-03T05:00:00-07:00", "2026-04-03T06:00:00-07:00"]
);
}
#[test]
fn detect_reports_without_translating() {
let out = stdout("2026-04-03T12:00:00Z", &["--detect"]);
assert_eq!(out, "2026-04-03T12:00:00Z\tiso\tZ");
let json = stdout("2026-04-03T12:00:00Z", &["--detect", "-j"]);
let v: serde_json::Value = serde_json::from_str(&json).unwrap();
assert!(v[0].get("translated").is_none());
assert_eq!(v[0]["detected_format"], "iso");
}
#[test]
fn applies_reference_date() {
assert_eq!(
stdout("15:30 PST", &["-t", "utc", "-d", "2026-01-15"]),
"23:30 UTC"
);
assert_eq!(
stdout("15:30 PST", &["-t", "utc", "-d", "January 15, 2026"]),
"23:30 UTC"
);
}
#[test]
fn rejects_combining_inplace_with_json() {
let (out, ok) = run("15:30 PST\n", &["-i", "-j", "/tmp/whatever.txt"], "UTC");
assert!(!ok);
assert!(out.is_empty());
}
#[test]
fn aborts_on_unparseable_date() {
let (_out, ok) = run("15:30 PST\n", &["-d", "not-a-date"], "UTC");
assert!(!ok);
}
fn verbose_bare(args: &[&str]) -> Output {
run_tz(b"15:30\n", args, Some("America/Los_Angeles"))
}
#[test]
fn verbose_discloses_the_assumptions_a_bare_timestamp_forces() {
let o = verbose_bare(&["-v", "-t", "nyc"]);
assert!(o.ok, "{}", o.stderr);
let lines: Vec<&str> = o.stderr.lines().collect();
assert!(
lines.contains(&"tztr: from=America/Los_Angeles (implicit, from $TZ) to=America/New_York"),
"{lines:?}"
);
assert!(
lines
.iter()
.any(|l| l.starts_with("tztr: no -d given, assuming ")
&& l.ends_with(" for DST resolution")),
"{lines:?}"
);
assert!(!o.out().contains("tztr:"), "diagnostics leaked to stdout");
}
#[test]
fn verbose_suppresses_the_startup_line_when_the_source_zone_is_implicit() {
let o = verbose_bare(&["-v", "-t", "nyc"]);
assert!(
!o.stderr.contains("tztr: from=America/Los_Angeles to="),
"{}",
o.stderr
);
let o = verbose_bare(&["-v", "-f", "utc", "-t", "nyc"]);
assert!(
o.stderr.contains("tztr: from=UTC to=America/New_York"),
"{}",
o.stderr
);
let o = run_tz(b"15:30\n", &["-v"], None);
let expected = match tztr::system_zone() {
Some(zone) => format!("tztr: from={zone} (implicit, from the system zone) to=UTC"),
None => "tztr: from=auto to=UTC".to_string(),
};
assert!(o.stderr.contains(&expected), "{}", o.stderr);
}
#[test]
fn a_timestamp_with_no_zone_is_read_in_the_system_zone_when_tz_is_unset() {
let Some(zone) = tztr::system_zone() else {
return;
};
let o = run_tz(b"2026-01-15 12:00:00\n", &["-t", "UTC"], None);
assert_eq!(
o.out().trim_end(),
tztr::translate("2026-01-15 12:00:00", "UTC", Some(&zone), None, None)
);
}
#[test]
fn verbose_dates_the_dst_assumption_where_the_timestamp_was_written() {
let o = verbose_bare(&["-v", "-t", "Pacific/Auckland"]);
let expected = format!(
"tztr: no -d given, assuming {} for DST resolution",
tztr::today_in_zone("America/Los_Angeles")
);
assert!(o.stderr.contains(&expected), "{}", o.stderr);
}
#[test]
fn verbose_discloses_the_date_assumption_even_when_the_match_names_a_zone() {
let o = run_tz(b"15:30 UTC\n", &["-v", "-t", "nyc"], None);
assert!(o.ok, "{}", o.stderr);
let expected = format!(
"tztr: no -d given, assuming {} for DST resolution",
tztr::today_in_zone("UTC")
);
assert!(o.stderr.contains(&expected), "{}", o.stderr);
let o = run_tz(
b"15:30 UTC\n",
&["-v", "-t", "nyc", "-d", "2026-01-15"],
None,
);
assert!(!o.stderr.contains("no -d given"), "{}", o.stderr);
assert_eq!(o.out().trim_end(), "10:30 EST");
}
#[test]
fn verbose_does_not_claim_a_source_zone_the_timestamp_carried_itself() {
let o = verbose_bare(&["-v", "-t", "nyc"]);
assert!(o.stderr.contains("(implicit, from $TZ)"), "{}", o.stderr);
let o = run_tz(
b"15:30 UTC\n",
&["-v", "-t", "nyc"],
Some("America/Los_Angeles"),
);
assert!(o.ok, "{}", o.stderr);
assert!(!o.stderr.contains("(implicit, from $TZ)"), "{}", o.stderr);
assert!(o.stderr.contains("no -d given"), "{}", o.stderr);
}
#[test]
fn verbose_discloses_each_assumption_the_first_time_it_is_made() {
let o = run_tz(
b"15:30 UTC\n15:30\n15:30\n",
&["-v", "-t", "nyc"],
Some("America/Los_Angeles"),
);
assert!(o.ok, "{}", o.stderr);
assert_eq!(o.stderr.matches("no -d given").count(), 1, "{}", o.stderr);
assert_eq!(
o.stderr.matches("(implicit, from $TZ)").count(),
1,
"{}",
o.stderr
);
let date_at = o.stderr.find("no -d given").unwrap();
let zone_at = o.stderr.find("(implicit, from $TZ)").unwrap();
assert!(date_at < zone_at, "{}", o.stderr);
}
#[test]
fn verbose_discloses_under_in_place_too() {
let path = temp_path("tztr-inplace-verbose");
std::fs::write(&path, "15:30\n").unwrap();
let o = run_tz(
b"",
&["-i", "-v", "-t", "nyc", path.to_str().unwrap()],
Some("America/Los_Angeles"),
);
let written = std::fs::read_to_string(&path).unwrap();
std::fs::remove_file(&path).unwrap();
assert!(o.ok, "{}", o.stderr);
assert!(o.stderr.contains("(implicit, from $TZ)"), "{}", o.stderr);
assert!(o.stderr.contains("no -d given"), "{}", o.stderr);
assert_ne!(written, "15:30\n", "file should have been translated");
}
#[test]
fn verbose_stays_quiet_when_nothing_was_assumed() {
let o = verbose_bare(&["-v", "-f", "pst", "-t", "nyc", "-d", "2026-01-15"]);
assert!(!o.stderr.contains("implicit"), "{}", o.stderr);
assert!(!o.stderr.contains("no -d given"), "{}", o.stderr);
let o = run_tz(
b"2026-04-03T12:00:00Z\n",
&["-v", "-t", "nyc"],
Some("America/Los_Angeles"),
);
assert!(!o.stderr.contains("implicit"), "{}", o.stderr);
assert!(!o.stderr.contains("no -d given"), "{}", o.stderr);
}
#[test]
fn verbose_names_a_mixed_case_zone_it_ignored_once() {
let o = run_tz(b"15:30 Pst\n16:00 Pst\n", &["-v", "-d", "2026-04-03"], None);
assert_eq!(
o.stderr.matches(r#"ignored "Pst""#).count(),
1,
"{}",
o.stderr
);
assert!(o.stderr.contains(
r#"tztr: ignored "Pst": a zone abbreviation is matched in all uppercase or all lowercase"#
));
let o = run_tz(
"à 15:30 est annulée\n".as_bytes(),
&["-v", "-d", "2026-04-03"],
None,
);
assert!(!o.stderr.contains("ignored"), "{}", o.stderr);
}
#[test]
fn verbose_discloses_once_and_leaves_structured_stdout_clean() {
let o = run_tz(
b"15:30\n16:30\n17:30\n",
&["-v", "-t", "nyc", "-j"],
Some("America/Los_Angeles"),
);
assert!(o.ok, "{}", o.stderr);
serde_json::from_str::<serde_json::Value>(o.out()).expect("stdout is still JSON");
assert_eq!(o.stderr.matches("(implicit, from $TZ)").count(), 1);
assert_eq!(o.stderr.matches("no -d given").count(), 1);
}
#[test]
fn help_option_lines_use_option_parsers_columns() {
let text = stdout("", &["-h"]);
let lines: Vec<&str> = text
.lines()
.filter(|l| l.starts_with(" -") || l.starts_with(" --"))
.collect();
assert_eq!(lines.len(), 12, "expected one line per option");
for l in lines {
let b = l.as_bytes();
assert!(b.len() > 37, "{l:?}");
assert_eq!(b[36], b' ', "flag column not padded to 33: {l:?}");
assert_ne!(b[37], b' ', "description not at column 37: {l:?}");
}
}
#[test]
fn accepts_the_posix_double_dash_terminator() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "pst", "--"]),
"2026-04-03T05:00:00-07:00"
);
let path = std::env::temp_dir().join("-tztr-dashed.log");
std::fs::write(&path, "2026-04-03T12:00:00Z\n").unwrap();
let o = run_tz(
b"",
&["-t", "pst", "--", path.to_str().unwrap()],
Some("UTC"),
);
assert!(o.ok, "{}", o.stderr);
assert_eq!(o.out().trim_end(), "2026-04-03T05:00:00-07:00");
std::fs::remove_file(&path).unwrap();
}
#[test]
fn accepts_the_documented_date_forms() {
for date in [
"2026-01-15",
"2026/01/15",
"20260115",
"January 15, 2026",
"Jan 15 2026",
"Jan. 15, 2026",
"Sep 15 2026", "15 January 2026",
] {
assert_eq!(
stdout("15:30 PST", &["-t", "utc", "-d", date]),
"23:30 UTC",
"{date}"
);
}
}
#[test]
fn rejects_dates_outside_that_set_and_dates_that_do_not_exist() {
for date in [
"2026-02-30", "2026-13-01",
"2026-00-10",
"not-a-date",
"01/15/2026", "15-01-2026",
"2026-01-15T00:00:00Z",
"Sept 15, 2026", "Janu 15 2026",
"2026-1-5", "2026/1/5",
] {
assert_eq!(
fails("15:30 PST\n", &["-t", "utc", "-d", date]),
format!("tztr: invalid date: {date}"),
"{date}"
);
}
}
#[test]
fn an_error_about_a_file_names_the_file() {
let missing = "/nonexistent/tztr-does-not-exist.log";
assert_eq!(
fails("", &["-t", "utc", missing]),
format!("tztr: {missing}: No such file or directory (os error 2)")
);
assert_eq!(
fails("", &["-i", "-t", "utc", missing]),
format!("tztr: {missing}: No such file or directory (os error 2)")
);
assert_eq!(
fails("", &["-t", "utc", "/tmp"]),
"tztr: /tmp: Is a directory (os error 21)"
);
assert_eq!(
fails("", &["-i", "-t", "utc", "/tmp"]),
"tztr: /tmp: Is a directory (os error 21)"
);
}
#[test]
fn a_bad_file_is_reported_and_the_rest_still_run() {
let a = temp_path("tztr-continue-a");
let b = temp_path("tztr-continue-b");
let (a, b) = (a.to_str().unwrap(), b.to_str().unwrap());
for f in [a, b] {
std::fs::write(f, "2026-04-03T12:00:00Z\n").unwrap();
}
let o = run_tz(b"", &["-t", "pst", a, "/tmp", a], None);
assert!(!o.ok);
assert_eq!(o.out(), "2026-04-03T05:00:00-07:00\n".repeat(2));
assert_eq!(
o.stderr.trim_end(),
"tztr: /tmp: Is a directory (os error 21)"
);
let o = run_tz(b"", &["-i", "-t", "pst", a, "/tmp", b], None);
assert!(!o.ok);
assert_eq!(
o.stderr.trim_end(),
"tztr: /tmp: Is a directory (os error 21)"
);
for f in [a, b] {
assert_eq!(
std::fs::read_to_string(f).unwrap(),
"2026-04-03T05:00:00-07:00\n"
);
std::fs::remove_file(f).unwrap();
}
}
#[test]
fn a_broken_pipe_is_not_blamed_on_the_input_file() {
let path = temp_path("tztr-epipe");
let body = "2026-04-03T12:00:00Z\n".repeat(50_000);
std::fs::write(&path, body).unwrap();
let out = Command::new("sh")
.arg("-c")
.arg(format!(
"{} -t pst {} | head -1",
bin(),
path.to_str().unwrap()
))
.env("TZ", "UTC")
.output()
.unwrap();
let stderr = String::from_utf8_lossy(&out.stderr);
std::fs::remove_file(&path).unwrap();
assert!(
stderr.is_empty() || stderr.trim_end() == "tztr: Broken pipe (os error 32)",
"unexpected stderr: {stderr:?}"
);
}
#[test]
fn rejects_an_inline_value_on_a_flag_that_takes_none() {
for flag in [
"--json",
"--ndjson",
"--detect",
"--verbose",
"--list",
"--in-place",
"--version",
"--help",
] {
assert_eq!(
fails("2026-04-03T12:00:00Z\n", &[&format!("{flag}=foo")]),
format!("tztr: {flag} takes no argument"),
"{flag}"
);
}
}
#[test]
fn still_accepts_an_inline_value_where_one_belongs() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["--format=short", "--to=nyc"]),
"2026-04-03 08:00 EDT"
);
assert_eq!(
stdout("15:30 PST", &["--to=utc", "--date=2026-01-15"]),
"23:30 UTC"
);
let out = stdout("2026-04-03T12:00:00Z", &["-j", "-t", "utc"]);
let v: serde_json::Value = serde_json::from_str(&out).unwrap();
assert_eq!(v[0]["translated"], "2026-04-03T12:00:00Z");
}
#[test]
fn errors_not_about_a_file_stay_bare() {
assert_eq!(
fails("2026-04-03T12:00:00Z\n", &["--bogus"]),
"tztr: invalid option: --bogus"
);
assert_eq!(
fails("2026-04-03T12:00:00Z\n", &["-t", "Bogus/Zone"]),
"tztr: unknown timezone: Bogus/Zone"
);
assert_eq!(
fails("15:30\n", &["-d", "not-a-date"]),
"tztr: invalid date: not-a-date"
);
}
#[test]
fn passes_invalid_utf8_lines_through_byte_for_byte() {
let input: &[u8] = b"2026-04-03T12:00:00Z \xff\xfe junk\n";
let o = run_tz(input, &["-t", "pst"], Some("UTC"));
assert!(o.ok, "{}", o.stderr);
assert_eq!(
o.stdout,
b"2026-04-03T05:00:00-07:00 \xff\xfe junk\n".to_vec()
);
}
#[test]
fn an_invalid_line_does_not_stop_the_valid_ones() {
let input: &[u8] = b"2026-04-03T12:00:00Z\n\xff\xfe\n2026-04-03T13:00:00Z\n";
let o = run_tz(input, &["-t", "utc"], Some("UTC"));
assert!(o.ok, "{}", o.stderr);
assert_eq!(
o.stdout,
b"2026-04-03T12:00:00Z\n\xff\xfe\n2026-04-03T13:00:00Z\n".to_vec()
);
}
#[test]
fn in_place_edit_keeps_bytes_it_cannot_decode() {
let path = temp_path("tztr-inplace-bytes");
std::fs::write(&path, b"2026-04-03T12:00:00Z \xff\xfe junk\n").unwrap();
let o = run_tz(
b"",
&["-i", "-t", "utc", path.to_str().unwrap()],
Some("pst"),
);
assert!(o.ok, "{}", o.stderr);
assert_eq!(
std::fs::read(&path).unwrap(),
b"2026-04-03T12:00:00Z \xff\xfe junk\n".to_vec()
);
std::fs::remove_file(&path).unwrap();
}
#[test]
fn structured_output_still_sees_timestamps_on_an_invalid_line() {
let input: &[u8] = b"2026-04-03T12:00:00Z \xff\xfe junk\n";
let o = run_tz(input, &["-t", "pst", "-j"], Some("UTC"));
assert!(o.ok, "{}", o.stderr);
let v: serde_json::Value = serde_json::from_str(o.out()).unwrap();
assert_eq!(v.as_array().unwrap().len(), 1);
assert_eq!(v[0]["original"], "2026-04-03T12:00:00Z");
assert_eq!(v[0]["translated"], "2026-04-03T05:00:00-07:00");
let o = run_tz(input, &["-t", "pst", "--detect"], Some("UTC"));
assert_eq!(o.out().trim_end(), "2026-04-03T12:00:00Z\tiso\tZ");
}
#[test]
fn short_format_always_labels_the_zone() {
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-F", "short"]),
"2026-04-03 12:00 UTC"
);
let o = run_tz(b"2026-04-03T12:00:00Z\n", &["-F", "short"], None);
assert_eq!(o.out().trim_end(), "2026-04-03 12:00 UTC");
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-F", "short", "-t", "nyc"]),
"2026-04-03 08:00 EDT"
);
let json = stdout("2026-04-03T12:00:00Z", &["-F", "short", "-j"]);
let v: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(v[0]["translated"], "2026-04-03 12:00 UTC");
}
#[test]
fn rejects_unknown_timezones() {
for (args, expected) in [
(["-t", "Bogus/Zone"], "tztr: unknown timezone: Bogus/Zone"),
(["-t", ""], "tztr: unknown timezone: "),
(
["-t", "America/New York"],
"tztr: unknown timezone: America/New York",
),
(["-f", "Bogus/Zone"], "tztr: unknown timezone: Bogus/Zone"),
] {
assert_eq!(fails("2026-04-03T12:00:00Z\n", &args), expected);
}
}
#[test]
fn rejects_out_of_range_numeric_offsets() {
for arg in ["15", "-13", "99"] {
assert_eq!(
fails("2026-04-03T12:00:00Z\n", &["-t", arg]),
format!("tztr: offset out of range: {arg} (expected -12..14)")
);
}
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "14"]),
"2026-04-04T02:00:00+14:00"
);
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "-12"]),
"2026-04-03T00:00:00-12:00"
);
}
#[test]
fn rejects_sub_hour_numeric_offsets() {
assert_eq!(
fails("2026-04-03T12:00:00Z\n", &["-t", "+5:30"]),
"tztr: unknown timezone: +5:30"
);
assert_eq!(
stdout("2026-04-03T12:00:00Z", &["-t", "ist"]),
"2026-04-03T17:30:00+05:30"
);
}
#[test]
fn rejects_an_unresolvable_tz_env() {
let o = run_tz(b"2026-04-03T12:00:00Z\n", &[], Some("Bogus/Zone"));
assert!(!o.ok);
assert_eq!(o.stderr.trim_end(), "tztr: unknown timezone: Bogus/Zone");
}
#[test]
fn honors_the_posix_leading_colon_on_tz() {
let o = run_tz(b"2026-04-03T12:00:00Z\n", &[], Some(":America/New_York"));
assert!(o.ok, "{}", o.stderr);
assert_eq!(o.out().trim_end(), "2026-04-03T08:00:00-04:00");
}
#[test]
fn treats_an_empty_tz_as_unset() {
let o = run_tz(b"2026-04-03T12:00:00Z\n", &[], Some(""));
assert!(o.ok, "{}", o.stderr);
assert_eq!(o.out().trim_end(), "2026-04-03T12:00:00Z");
}
#[test]
fn now_prints_the_current_time_in_iso_8601() {
let o = run_tz(b"", &["now"], None);
assert!(o.ok, "{}", o.stderr);
let out = o.out().trim_end();
let when: jiff::Timestamp = out.parse().expect("ISO 8601");
let drift = jiff::Timestamp::now().duration_since(when).as_secs().abs();
assert!(out.ends_with('Z') && drift < 5, "{out}");
let o = run_tz(b"", &["now"], Some("America/Los_Angeles"));
let out = o.out().trim_end();
assert!(out.ends_with("-07:00") || out.ends_with("-08:00"), "{out}");
}
#[test]
fn now_works_with_every_output_flag() {
let o = run_tz(b"", &["now", "-t", "tokyo", "-F", "short"], None);
assert!(o.out().trim_end().ends_with(" JST"), "{}", o.out());
let o = run_tz(b"", &["now", "-t", "tokyo", "-j"], None);
let v: serde_json::Value = serde_json::from_str(o.out()).unwrap();
assert!(v[0]["translated"].as_str().unwrap().ends_with("+09:00"));
let o = run_tz(b"", &["now", "--detect"], None);
assert!(o.out().trim_end().ends_with("\tiso\tZ"), "{}", o.out());
assert_eq!(
fails("", &["-i", "now"]),
"tztr: -i cannot be combined with now"
);
}
#[test]
fn verbose_does_not_flag_a_capitalized_word() {
let o = run_tz(
b"um 15:30 Ist das\n12:00 Mt. Everest\n15:30 Et al\n",
&["-v", "-d", "2026-04-03"],
None,
);
assert!(!o.stderr.contains("ignored"), "{}", o.stderr);
}