use async_graphql::{ScalarType, Value};
use jiff::{civil, tz};
use super::{LocalTimestamp, LocalTimestampOperand, render, split_offset};
fn wall() -> civil::DateTime {
civil::date(2021, 8, 14).at(16, 45, 9, 0)
}
fn parse(text: &str) -> Result<LocalTimestamp, String> {
crossed(<LocalTimestampOperand as ScalarType>::parse(Value::String(
String::from(text),
)))
}
fn crossed(
parsed: async_graphql::InputValueResult<LocalTimestampOperand>,
) -> Result<LocalTimestamp, String> {
parsed.map(|operand| operand.get()).map_err(|refused| {
refused
.into_server_error(async_graphql::Pos::default())
.message
})
}
#[test]
fn the_text_arm_reads_a_wall_clock_with_or_without_a_zone() {
assert_eq!(
parse("2021-08-14T16:45:09"),
Ok(LocalTimestamp::wall(wall()))
);
assert_eq!(
parse("2021-08-14T16:45:09+09:00"),
Ok(LocalTimestamp::at(wall(), tz::Offset::constant(9)))
);
assert_eq!(
parse("2021-08-14T16:45:09-04:30"),
Ok(LocalTimestamp::at(
wall(),
tz::Offset::from_seconds(-16_200).expect("inside the domain")
))
);
assert_eq!(
parse("2021-08-14T16:45:09Z"),
Ok(LocalTimestamp::at(wall(), tz::Offset::UTC)),
"`Z` is a STATED zone and not the absence of one"
);
}
#[test]
fn every_shape_renders_back_to_a_string_that_reads_as_itself() {
for capture in [
LocalTimestamp::wall(wall()),
LocalTimestamp::at(wall(), tz::Offset::UTC),
LocalTimestamp::at(wall(), tz::Offset::constant(9)),
LocalTimestamp::at(
civil::date(1892, 1, 1).at(0, 0, 0, 0),
tz::Offset::from_seconds(2_670).expect("a local mean time"),
),
LocalTimestamp::at(
civil::date(2021, 8, 14).at(16, 45, 9, 123_456_789),
tz::Offset::constant(-4),
),
] {
let written = render(capture);
assert_eq!(parse(&written), Ok(capture), "`{written}`");
assert_eq!(
LocalTimestampOperand::new(capture).to_value(),
Value::String(written)
);
}
}
#[test]
fn the_silent_file_and_the_utc_one_render_apart() {
assert_eq!(render(LocalTimestamp::wall(wall())), "2021-08-14T16:45:09");
assert_eq!(
render(LocalTimestamp::at(wall(), tz::Offset::UTC)),
"2021-08-14T16:45:09+00"
);
}
#[test]
fn the_structure_arm_reads_the_same_two_shapes() {
use async_graphql::{Name, indexmap::IndexMap};
fn object(pairs: &[(&str, Value)]) -> Result<LocalTimestamp, String> {
let mut held = IndexMap::new();
for (key, value) in pairs {
held.insert(Name::new(key), value.clone());
}
crossed(<LocalTimestampOperand as ScalarType>::parse(Value::Object(
held,
)))
}
let clock = Value::String(String::from("2021-08-14T16:45:09"));
assert_eq!(
object(&[("local", clock.clone())]),
Ok(LocalTimestamp::wall(wall()))
);
assert_eq!(
object(&[("local", clock.clone()), ("offset", Value::Null)]),
Ok(LocalTimestamp::wall(wall()))
);
assert_eq!(
object(&[
("local", clock.clone()),
("offset", Value::String(String::from("+09:00")))
]),
Ok(LocalTimestamp::at(wall(), tz::Offset::constant(9)))
);
assert!(object(&[]).is_err(), "the wall clock is not optional");
assert!(
object(&[("local", clock), ("zone", Value::Null)]).is_err(),
"an unknown key is named rather than ignored"
);
}
#[test]
fn the_operand_refuses_what_names_no_clock_face() {
assert!(
<LocalTimestampOperand as ScalarType>::parse(Value::Number(1_628_927_109.into())).is_err()
);
assert!(parse("").is_err());
assert!(parse("yesterday").is_err());
assert!(
parse("2021-08-14T16:45:09+26:00").is_err(),
"past the offset domain"
);
assert!(
parse("2021-08-14T16:45:09[Asia/Tokyo]").is_err(),
"a NAMED zone is not an offset"
);
}
#[test]
fn a_negative_year_is_not_read_as_a_zone() {
assert_eq!(
split_offset("-009999-01-01T00:00:00"),
("-009999-01-01T00:00:00", None)
);
assert_eq!(
split_offset("-009999-01-01T00:00:00+09:00"),
("-009999-01-01T00:00:00", Some("+09:00"))
);
assert!(parse("-009999-01-01T00:00:00").is_ok());
}
#[test]
fn validity_and_parsing_are_one_answer() {
for text in [
"2021-08-14T16:45:09",
"2021-08-14T16:45:09+09:00",
"yesterday",
"",
] {
let value = Value::String(String::from(text));
assert_eq!(
<LocalTimestampOperand as ScalarType>::is_valid(&value),
<LocalTimestampOperand as ScalarType>::parse(value.clone()).is_ok(),
"`{text}`"
);
}
}