use crate::{
ColumnKind, ColumnShape, CursorValue, FieldName, ParseTimeRangeError, TimeRange, TimeRanged,
Timestamp, leaf_names, width,
};
fn at(second: i64) -> Timestamp {
Timestamp::from_parts(second, 0).expect("an instant")
}
fn range(start: i64, end: i64) -> TimeRange {
TimeRange::new(at(start), at(end)).expect("a stretch")
}
#[test]
fn an_inverted_pair_is_not_a_range() {
let refused = TimeRange::new(at(20), at(10)).expect_err("20 is later than 10");
assert_eq!(refused.start(), at(20));
assert_eq!(refused.end(), at(10));
assert!(
refused
.to_string()
.contains("ends no earlier than it starts"),
"the sentence names the rule rather than only the values"
);
}
#[test]
fn the_two_ends_may_coincide() {
let marker = TimeRange::new(at(10), at(10)).expect("`start <= end` admits equality");
assert!(marker.is_instant());
assert_eq!(marker, TimeRange::instant(at(10)));
assert!(
!marker.holds(at(10)),
"a half-open stretch of zero width covers no instant at all"
);
assert!(!marker.contains(&range(10, 11)));
}
#[test]
fn the_start_is_in_and_the_end_is_out() {
let span = range(0, 10);
assert!(span.holds(at(0)), "the start is in the stretch");
assert!(span.holds(at(9)));
assert!(!span.holds(at(10)), "the end is not");
assert!(!span.holds(at(11)));
assert!(!range(0, 10).holds(at(10)));
assert!(range(10, 20).holds(at(10)));
}
#[test]
fn overlapping_is_sharing_an_instant() {
assert!(range(0, 10).overlaps(&range(5, 15)));
assert!(range(5, 15).overlaps(&range(0, 10)));
assert!(range(0, 10).overlaps(&range(2, 3)), "wholly inside counts");
assert!(!range(0, 10).overlaps(&range(11, 20)));
}
#[test]
fn abutting_stretches_do_not_meet() {
assert!(!range(0, 10).overlaps(&range(10, 20)));
assert!(!range(10, 20).overlaps(&range(0, 10)), "and symmetrically");
assert!(range(0, 11).overlaps(&range(10, 20)));
}
#[test]
fn containment_reads_both_ways() {
let wide = range(0, 100);
let narrow = range(10, 20);
assert!(wide.contains(&narrow));
assert!(narrow.within(&wide));
assert!(!narrow.contains(&wide));
assert!(wide.contains(&wide), "containment is reflexive");
}
#[test]
fn a_degenerate_operand_is_not_the_membership_test() {
let span = range(10, 20);
assert!(!span.holds(at(20)));
assert!(span.contains(&TimeRange::instant(at(20))));
assert!(!span.overlaps(&TimeRange::instant(at(20))));
assert!(span.holds(at(10)));
assert!(span.contains(&TimeRange::instant(at(10))));
assert!(!span.overlaps(&TimeRange::instant(at(10))));
assert!(span.contains(&range(12, 18)), "the span shape still works");
}
#[test]
fn the_forms_read_a_degenerate_operand_as_its_position() {
let span = range(0, 10);
assert!(!span.overlaps(&TimeRange::instant(at(10))));
assert!(span.overlaps(&TimeRange::instant(at(5))));
assert!(span.contains(&TimeRange::instant(at(10))));
assert!(!span.contains(&TimeRange::instant(at(20))));
}
#[test]
fn the_cursor_orders_by_start_then_end() {
fn token(span: TimeRange) -> Vec<u8> {
let mut out = Vec::new();
span.write_cursor(&mut out);
out
}
let mut tokens = [range(10, 12), range(0, 100), range(10, 11), range(0, 5)].map(token);
tokens.sort();
let read: Vec<TimeRange> = tokens
.iter()
.map(|bytes| TimeRange::read_cursor(bytes).expect("its own encoding"))
.collect();
assert_eq!(
read,
[range(0, 5), range(0, 100), range(10, 11), range(10, 12)],
"earlier starts first, and a tie breaks on the earlier end"
);
}
#[test]
fn the_text_form_is_the_half_open_notation() {
assert_eq!(
range(0, 60).to_string(),
"[1970-01-01T00:00:00Z, 1970-01-01T00:01:00Z)"
);
assert_eq!(
range(0, 60).to_string().parse::<TimeRange>().unwrap(),
range(0, 60),
"`Display` and `FromStr` are inverse"
);
}
#[test]
fn a_text_that_is_not_a_stretch_says_which_half_broke() {
assert!(matches!(
"1970-01-01T00:00:00Z".parse::<TimeRange>(),
Err(ParseTimeRangeError::Notation)
));
assert!(matches!(
"[1970-01-01T00:00:00Z]".parse::<TimeRange>(),
Err(ParseTimeRangeError::Notation)
));
assert!(matches!(
"[not-an-instant, 1970-01-01T00:01:00Z)".parse::<TimeRange>(),
Err(ParseTimeRangeError::Endpoint(_))
));
assert!(matches!(
"[1970-01-01T00:01:00Z, 1970-01-01T00:00:00Z)".parse::<TimeRange>(),
Err(ParseTimeRangeError::Inverted(_))
));
}
const RANGE_LEAVES: &[&FieldName] = &[
FieldName::new("start_secs"),
FieldName::new("start_nanos"),
FieldName::new("end_secs"),
FieldName::new("end_nanos"),
];
const _: () = assert!(leaf_names(
<TimeRange as ColumnKind>::SEGMENTS,
RANGE_LEAVES
));
const _: () = assert!(width(<TimeRange as ColumnKind>::SEGMENTS) == 4);
const _: () = assert!(<TimeRange as ColumnKind>::SEGMENTS.len() == 2);
const TIMED_LEAVES: &[&FieldName] = &[
FieldName::new("start_secs"),
FieldName::new("start_nanos"),
FieldName::new("end_secs"),
FieldName::new("end_nanos"),
FieldName::new("data"),
];
const _: () = assert!(leaf_names(
<TimeRanged<i64> as ColumnKind>::SEGMENTS,
TIMED_LEAVES
));
const _: () = assert!(width(<TimeRanged<i64> as ColumnKind>::SEGMENTS) == 5);
#[test]
fn the_segments_are_the_instants_own_under_two_seats() {
let segments = <TimeRange as ColumnKind>::SEGMENTS;
let ColumnShape::Composite {
field: Some(start),
segments: inner,
} = segments[0]
else {
panic!("a seat of a range is a composite lending its own name");
};
assert_eq!(start.stored().as_str(), "start");
assert_eq!(
inner,
<Timestamp as ColumnKind>::SEGMENTS,
"not a second spelling of an instant's storage"
);
let timed = <TimeRanged<i64> as ColumnKind>::SEGMENTS;
assert!(
matches!(timed[0], ColumnShape::Composite { field: None, .. }),
"the stretch splices into its holder's namespace"
);
assert!(
matches!(timed[1], ColumnShape::Plain(data) if data.stored().as_str() == "data"),
"a scalar payload is one column under `data`"
);
}
#[test]
fn a_composite_payload_nests_under_its_seat() {
let timed = <TimeRanged<TimeRange> as ColumnKind>::SEGMENTS;
assert_eq!(width(timed), 8, "four leaves apiece");
assert!(
matches!(timed[1], ColumnShape::Composite { field: Some(data), segments } if data.stored().as_str() == "data"
&& segments == <TimeRange as ColumnKind>::SEGMENTS),
"the payload's own parts hang beneath `data` rather than beside the stretch's"
);
}
#[test]
fn the_cursor_round_trips_and_re_validates() {
let span = TimeRange::new(
Timestamp::from_parts(1_756_371_600, 123_456_789).expect("an instant"),
Timestamp::from_parts(1_756_371_660, 0).expect("an instant"),
)
.expect("a stretch");
let mut bytes = Vec::new();
span.write_cursor(&mut bytes);
assert_eq!(bytes.len(), 24, "two instants of twelve bytes each");
assert_eq!(TimeRange::read_cursor(&bytes), Some(span));
let mut inverted = Vec::new();
span.end().write_cursor(&mut inverted);
span.start().write_cursor(&mut inverted);
assert_eq!(
TimeRange::read_cursor(&inverted),
None,
"the pair goes back through `TimeRange::new`"
);
assert_eq!(TimeRange::read_cursor(&bytes[..23]), None);
assert_eq!(TimeRange::read_cursor(&[]), None);
}
#[test]
fn a_timed_cursor_splits_at_the_stretchs_fixed_width() {
let timed = TimeRanged::new(range(10, 20), String::from("zh-Hans"));
let mut bytes = Vec::new();
timed.write_cursor(&mut bytes);
assert_eq!(bytes.len(), 24 + "zh-Hans".len());
assert_eq!(TimeRanged::<String>::read_cursor(&bytes), Some(timed));
let mut inverted = Vec::new();
range(10, 20).end().write_cursor(&mut inverted);
range(10, 20).start().write_cursor(&mut inverted);
inverted.extend_from_slice(b"zh");
assert_eq!(TimeRanged::<String>::read_cursor(&inverted), None);
assert_eq!(TimeRanged::<String>::read_cursor(&bytes[..20]), None);
}
#[test]
fn the_payload_maps_without_the_timing_being_rebuilt() {
let timed = TimeRanged::new(range(0, 10), 7i64);
let mapped = timed.map(|held| held * 2);
assert_eq!(mapped.range(), &range(0, 10));
assert_eq!(*mapped.data(), 14);
let (stretch, held) = mapped.into_parts();
assert_eq!(stretch, range(0, 10));
assert_eq!(held, 14);
}
#[test]
fn a_timed_payload_has_equality_and_a_cursor_order() {
assert_eq!(
TimeRanged::new(range(10, 20), 1i64),
TimeRanged::new(range(10, 20), 1i64)
);
assert_ne!(
TimeRanged::new(range(10, 20), 1i64),
TimeRanged::new(range(10, 20), 0i64)
);
fn token(timed: TimeRanged<i64>) -> Vec<u8> {
let mut out = Vec::new();
timed.write_cursor(&mut out);
out
}
let mut tokens = [
TimeRanged::new(range(10, 20), 1i64),
TimeRanged::new(range(0, 5), 9i64),
TimeRanged::new(range(10, 20), 0i64),
]
.map(token);
tokens.sort();
let read: Vec<TimeRanged<i64>> = tokens
.iter()
.map(|bytes| TimeRanged::read_cursor(bytes).expect("its own encoding"))
.collect();
assert_eq!(
read,
[
TimeRanged::new(range(0, 5), 9),
TimeRanged::new(range(10, 20), 0),
TimeRanged::new(range(10, 20), 1),
],
"the stretch orders first and the payload breaks the tie"
);
}
#[cfg(feature = "mongo")]
mod document {
use super::{at, range};
use crate::{
MongoCarrier, TimeRange, TimeRanged, Timestamp,
query::mongo::{MongoExtract, MongoTypeError},
};
#[test]
fn a_stretch_is_two_nested_instants() {
let span = range(10, 20);
let bson::Bson::Document(document) = span.to_bson() else {
panic!("a stretch writes a document");
};
assert_eq!(document.len(), 2);
assert_eq!(
document.get("start"),
Some(&Timestamp::to_bson(&at(10))),
"the seat holds the INSTANT's own form"
);
assert_eq!(TimeRange::extract(Some(&span.to_bson())), Ok(span));
}
#[test]
fn an_inverted_document_is_refused() {
let mut document = bson::Document::new();
document.insert("start", Timestamp::to_bson(&at(20)));
document.insert("end", Timestamp::to_bson(&at(10)));
let refused = TimeRange::extract(Some(&bson::Bson::Document(document)));
assert!(matches!(refused, Err(MongoTypeError::Range(_))));
assert!(matches!(
TimeRange::extract(Some(&bson::Bson::Int32(3))),
Err(MongoTypeError::Type { .. })
));
assert!(matches!(
TimeRange::extract(None),
Err(MongoTypeError::Absent)
));
}
#[test]
fn a_timed_payload_splices_its_stretch_and_names_its_payload() {
let timed = TimeRanged::new(range(10, 20), 7i64);
let bson::Bson::Document(document) = timed.to_bson() else {
panic!("a timed payload writes a document");
};
assert_eq!(document.len(), 3);
assert!(document.contains_key("start"));
assert!(document.contains_key("end"));
assert_eq!(document.get("data"), Some(&bson::Bson::Int64(7)));
assert_eq!(
TimeRanged::<i64>::extract(Some(&timed.to_bson())),
Ok(timed)
);
}
}