use async_graphql::{InputType, OutputType, Pos, Value};
use crate::{
Contained, ContainedOperand, ScalarFilter, TimeRange, TimeRangeFilter, TimeRangeOperand,
TimeRanged, TimeRangedFilter, Timestamp,
};
fn at(second: i64) -> Timestamp {
Timestamp::from_parts(second, 0).expect("an instant")
}
fn sent(start: &str, end: &str) -> Value {
let mut object = async_graphql::indexmap::IndexMap::new();
object.insert(async_graphql::Name::new("start"), Value::from(start));
object.insert(async_graphql::Name::new("end"), Value::from(end));
Value::Object(object)
}
fn door(value: Value) -> Result<TimeRangeOperand, String> {
<TimeRangeOperand as InputType>::parse(Some(value))
.map_err(|refused| refused.into_server_error(Pos::default()).message)
}
#[test]
fn the_seats_are_the_instants_own_grammar() {
let admitted = door(sent("1970-01-01T00:00:10Z", "1970-01-01T00:00:20Z")).expect("a stretch");
assert_eq!(admitted.get(), TimeRange::new(at(10), at(20)).unwrap());
let offset = door(sent("1970-01-01T09:00:10+09:00", "1970-01-01T00:00:20Z")).expect("a stretch");
assert_eq!(offset.get().start(), at(10));
assert!(door(sent("1970-01-01T00:00:10", "1970-01-01T00:00:20Z")).is_err());
}
#[test]
fn an_inverted_operand_is_refused_with_the_rule() {
let refused =
door(sent("1970-01-01T00:00:20Z", "1970-01-01T00:00:10Z")).expect_err("20 is after 10");
assert!(
refused.contains("ends no earlier than it starts"),
"{refused}"
);
}
#[test]
fn a_degenerate_operand_crosses() {
let point = door(sent("1970-01-01T00:00:15Z", "1970-01-01T00:00:15Z")).expect("an instant span");
assert!(point.get().is_instant());
}
#[test]
fn the_contained_door_reads_a_position_or_a_span() {
fn contained(value: Value) -> Result<Contained, String> {
<ContainedOperand as InputType>::parse(Some(value))
.map(|operand| operand.get())
.map_err(|refused| refused.into_server_error(Pos::default()).message)
}
assert_eq!(
contained(Value::from("1970-01-01T00:00:15Z")).expect("a position"),
Contained::Instant(at(15))
);
assert_eq!(
contained(Value::from("[1970-01-01T00:00:10Z, 1970-01-01T00:00:20Z)")).expect("a span"),
Contained::Span(TimeRange::new(at(10), at(20)).unwrap())
);
let inverted = contained(Value::from("[1970-01-01T00:00:20Z, 1970-01-01T00:00:10Z)"))
.expect_err("20 is after 10");
assert!(
inverted.contains("ends no earlier than it starts"),
"{inverted}"
);
let endpoints = contained(Value::from("[nonsense, more)")).expect_err("not a stretch");
assert!(endpoints.contains("not an instant"), "{endpoints}");
let notation = contained(Value::from("[nonsense)")).expect_err("no comma, no stretch");
assert!(notation.contains("half-open reading"), "{notation}");
assert_eq!(
InputType::to_value(&ContainedOperand::new(Contained::Instant(at(15)))),
Value::from("1970-01-01T00:00:15Z")
);
assert_eq!(
InputType::to_value(&ContainedOperand::new(Contained::Span(
TimeRange::new(at(10), at(20)).unwrap()
))),
Value::from("[1970-01-01T00:00:10Z, 1970-01-01T00:00:20Z)")
);
assert!(
contained(Value::from(15)).is_err(),
"a number is not a shape"
);
}
#[test]
fn a_missing_seat_is_refused() {
let mut half = async_graphql::indexmap::IndexMap::new();
half.insert(
async_graphql::Name::new("start"),
Value::from("1970-01-01T00:00:10Z"),
);
assert!(door(Value::Object(half)).is_err());
assert!(door(Value::Null).is_err());
assert!(
door(Value::from("1970-01-01T00:00:10Z")).is_err(),
"a range has two seats and neither is the obvious one, so there is no bare form"
);
}
#[test]
fn the_operand_renders_the_two_seats_it_takes() {
let operand = TimeRangeOperand::new(TimeRange::new(at(10), at(20)).unwrap());
let rendered = InputType::to_value(&operand);
assert_eq!(door(rendered).expect("its own form").get(), operand.get());
}
#[test]
fn a_bare_value_at_the_range_filter_is_a_named_refusal() {
let bare = <TimeRangeFilter as InputType>::parse(Some(Value::from("1970-01-01T00:00:10Z")))
.expect_err("a bare value does not say which word was meant");
let message = bare.into_server_error(Pos::default()).message;
assert!(message.contains("overlaps"), "{message}");
assert!(message.contains("contains"), "{message}");
assert!(message.contains("within"), "{message}");
}
#[test]
fn the_two_component_keys_are_not_an_interval_operand() {
let filter = <TimeRangeFilter as InputType>::parse(Some(sent(
"1970-01-01T00:00:10Z",
"1970-01-01T00:00:20Z",
)))
.expect("the two component slots, each taking its own shorthand");
assert!(filter.overlaps().is_none());
assert_eq!(filter.start().and_then(ScalarFilter::eq), Some(&at(10)));
assert_eq!(filter.end().and_then(ScalarFilter::eq), Some(&at(20)));
}
#[test]
fn the_range_filter_takes_its_five_slots() {
let mut object = async_graphql::indexmap::IndexMap::new();
object.insert(
async_graphql::Name::new("overlaps"),
sent("1970-01-01T00:00:10Z", "1970-01-01T00:00:20Z"),
);
let filter = <TimeRangeFilter as InputType>::parse(Some(Value::Object(object)))
.expect("one named interval word");
assert_eq!(
filter.overlaps().map(TimeRangeOperand::get),
Some(TimeRange::new(at(10), at(20)).unwrap())
);
assert!(filter.contains().is_none());
let empty = <TimeRangeFilter as InputType>::parse(Some(Value::Object(Default::default())))
.expect("an empty object");
assert!(empty.is_empty());
}
#[test]
fn the_range_filter_round_trips_its_own_rendering() {
let filter = TimeRangeFilter::new()
.with_within(TimeRange::new(at(0), at(100)).unwrap())
.with_start(ScalarFilter::new().with_gte(at(5)));
let rendered = InputType::to_value(&filter);
let read = <TimeRangeFilter as InputType>::parse(Some(rendered)).expect("its own form");
assert_eq!(read, filter);
}
#[test]
fn a_bare_value_at_the_timed_filter_is_a_named_refusal() {
let bare = <TimeRangedFilter<ScalarFilter<i64>> as InputType>::parse(Some(Value::from(7)))
.expect_err("a bare value does not say which half");
let message = bare.into_server_error(Pos::default()).message;
assert!(message.contains("range"), "{message}");
assert!(message.contains("data"), "{message}");
}
#[test]
fn the_timed_filter_takes_a_stretch_and_a_payload() {
let filter = TimeRangedFilter::new()
.with_range(TimeRangeFilter::new().with_overlaps(TimeRange::new(at(10), at(20)).unwrap()))
.with_data(ScalarFilter::<i64>::new().with_eq(7i64));
let rendered = InputType::to_value(&filter);
let read = <TimeRangedFilter<ScalarFilter<i64>> as InputType>::parse(Some(rendered))
.expect("its own form");
assert_eq!(read, filter);
assert!(!read.is_empty());
assert!(TimeRangedFilter::<ScalarFilter<i64>>::new().is_empty());
}
#[test]
fn the_published_names_are_composed_from_the_parameter() {
assert_eq!(<TimeRange as OutputType>::type_name(), "TimeRange");
assert_eq!(
<TimeRangeOperand as InputType>::type_name(),
"TimeRangeOperand"
);
assert_eq!(
<TimeRangeFilter as InputType>::type_name(),
"TimeRangeFilter"
);
assert_eq!(
<TimeRanged<Timestamp> as OutputType>::type_name(),
"TimeRangedTimestamp"
);
assert_eq!(
<TimeRangedFilter<ScalarFilter<Timestamp>> as InputType>::type_name(),
"TimeRangedTimestampFilter"
);
assert_eq!(
<TimeRangedFilter<ScalarFilter<i64>> as InputType>::type_name(),
"TimeRangedI64Filter"
);
}
#[test]
fn the_schema_publishes_both_citizens() {
struct Query;
#[async_graphql::Object]
impl Query {
async fn heard(
&self,
_asked: TimeRangedFilter<ScalarFilter<Timestamp>>,
) -> TimeRanged<Timestamp> {
TimeRanged::new(TimeRange::instant(at(0)), at(0))
}
async fn trim(&self, _asked: TimeRangeFilter) -> TimeRange {
TimeRange::instant(at(0))
}
}
fn shape(sdl: &str) -> String {
let mut stripped = String::new();
let mut inside = false;
for line in sdl.lines() {
let trimmed = line.trim();
if trimmed.starts_with("\"\"\"") {
if trimmed == "\"\"\"" {
inside = !inside;
}
continue;
}
if inside {
continue;
}
stripped.push_str(line);
stripped.push('\n');
}
stripped
}
let sdl = shape(
&async_graphql::Schema::new(
Query,
async_graphql::EmptyMutation,
async_graphql::EmptySubscription,
)
.sdl(),
);
for block in [
"type TimeRange {\n\tstart: Timestamp!\n\tend: Timestamp!\n}",
"input TimeRangeOperand {\n\tstart: Timestamp!\n\tend: Timestamp!\n}",
"input TimeRangeFilter {\n\toverlaps: TimeRangeOperand\n\tcontains: ContainedOperand\n\twithin: \
TimeRangeOperand\n\tstart: TimestampFilter\n\tend: TimestampFilter\n}",
"scalar ContainedOperand",
"type TimeRangedTimestamp {\n\trange: TimeRange!\n\tdata: Timestamp!\n}",
"input TimeRangedTimestampFilter {\n\trange: TimeRangeFilter\n\tdata: TimestampFilter\n}",
] {
assert!(
sdl.contains(block),
"missing from the SDL:\n{block}\n\n{sdl}"
);
}
}
#[test]
fn a_nullable_column_gets_the_twin() {
use crate::Nullable;
assert_eq!(
<Nullable<TimeRangeFilter> as InputType>::type_name(),
"NullableTimeRangeFilter"
);
assert_eq!(
<Nullable<TimeRangedFilter<ScalarFilter<i64>>> as InputType>::type_name(),
"NullableTimeRangedI64Filter"
);
}