use bson::{Bson, Document, doc};
use jiff::SignedDuration;
use super::MongoDurationComparison;
use crate::{
At, ComplexComparison, DurationFilter, DurationOutOfRange, FieldName, Mongo, RecordAddress,
ToDatabaseComparison, TryFromFilter, comparison::mongo::MongoConjunction,
};
const ROW: RecordAddress = RecordAddress::new(FieldName::new("media"), &[FieldName::new("id")]);
const CEILING: SignedDuration = SignedDuration::new(9_223_372_036, 854_775_807);
const FLOOR: SignedDuration = SignedDuration::new(-9_223_372_036, -854_775_808);
fn rendered<C: ComplexComparison<Mongo>>(comparison: &C, column: &str) -> Document {
let frame = At::new(&ROW).frame(FieldName::new(column));
comparison
.apply(frame.at(), MongoConjunction::new())
.expect("a MongoDB lowering cannot refuse")
.into_document()
}
#[test]
fn every_operator_maps_one_to_one_and_merges() {
let comparison = MongoDurationComparison::<i64>::try_from_filter(
DurationFilter::new()
.with_eq(SignedDuration::from_secs(1))
.with_ne(SignedDuration::from_secs(2))
.with_gt(SignedDuration::from_secs(3))
.with_gte(SignedDuration::from_secs(4))
.with_lt(SignedDuration::from_secs(5))
.with_lte(SignedDuration::from_secs(6))
.with_in_([SignedDuration::from_secs(7), SignedDuration::from_secs(8)])
.with_not_in([SignedDuration::from_secs(9)]),
)
.expect("every operand is well inside the ceiling");
assert_eq!(comparison.conjuncts(), 8);
assert_eq!(
rendered(&comparison, "len"),
doc! {
"len": {
"$eq": 1_000_000_000_i64,
"$ne": 2_000_000_000_i64,
"$gt": 3_000_000_000_i64,
"$gte": 4_000_000_000_i64,
"$lt": 5_000_000_000_i64,
"$lte": 6_000_000_000_i64,
"$in": [7_000_000_000_i64, 8_000_000_000_i64],
"$nin": [9_000_000_000_i64],
}
}
);
}
#[test]
fn an_operand_reaches_bson_as_an_int64_of_nanoseconds() {
let comparison = MongoDurationComparison::<i64>::try_from_filter(
DurationFilter::new().with_eq(SignedDuration::from_secs(3600) + SignedDuration::from_nanos(1)),
)
.expect("an hour is well inside the ceiling");
let filter = rendered(&comparison, "len");
let operand = filter
.get_document("len")
.expect("the field holds an operator document")
.get("$eq")
.expect("the operator is present");
assert_eq!(operand, &Bson::Int64(3_600_000_000_001));
}
#[test]
fn the_ceiling_is_a_refusal_and_not_a_truncation() {
let crossed =
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_eq(CEILING))
.expect("i64::MAX nanoseconds is storable");
assert_eq!(crossed.eq(), Some(&i64::MAX));
let over = CEILING + SignedDuration::from_nanos(1);
assert_eq!(
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_eq(over))
.unwrap_err(),
DurationOutOfRange
);
assert_eq!(over.as_nanos() as i64, i64::MIN);
}
#[test]
fn the_floor_is_a_refusal_and_the_last_legal_value_below_zero_is_not() {
let crossed =
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_eq(FLOOR))
.expect("i64::MIN nanoseconds is storable");
assert_eq!(crossed.eq(), Some(&i64::MIN));
assert_eq!(
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_eq(-FLOOR))
.unwrap_err(),
DurationOutOfRange
);
let under = FLOOR - SignedDuration::from_nanos(1);
assert_eq!(
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_eq(under))
.unwrap_err(),
DurationOutOfRange
);
assert_eq!(under.as_nanos() as i64, i64::MAX);
}
#[test]
fn a_negative_operand_crosses_and_stays_negative() {
let comparison = MongoDurationComparison::<i64>::try_from_filter(
DurationFilter::new()
.with_gte(SignedDuration::from_secs(-2))
.with_in_([SignedDuration::from_secs(-1), SignedDuration::from_secs(1)]),
)
.expect("a negative duration is well inside the floor");
assert_eq!(
rendered(&comparison, "offset"),
doc! {
"offset": {
"$gte": -2_000_000_000_i64,
"$in": [-1_000_000_000_i64, 1_000_000_000_i64],
}
}
);
}
fn leaked(slots: impl IntoIterator<Item = (&'static str, DurationFilter)>) -> Vec<&'static str> {
slots
.into_iter()
.filter(|(_, filter)| MongoDurationComparison::<i64>::try_from_filter(filter.clone()).is_ok())
.map(|(slot, _)| slot)
.collect()
}
#[test]
fn every_inline_slot_refuses_an_out_of_range_operand() {
let over = CEILING + SignedDuration::from_nanos(1);
let under = FLOOR - SignedDuration::from_nanos(1);
let crossed = leaked([
("eq+", DurationFilter::new().with_eq(over)),
("ne+", DurationFilter::new().with_ne(over)),
("gt+", DurationFilter::new().with_gt(over)),
("gte+", DurationFilter::new().with_gte(over)),
("lt+", DurationFilter::new().with_lt(over)),
("lte+", DurationFilter::new().with_lte(over)),
("eq-", DurationFilter::new().with_eq(under)),
("ne-", DurationFilter::new().with_ne(under)),
("gt-", DurationFilter::new().with_gt(under)),
("gte-", DurationFilter::new().with_gte(under)),
("lt-", DurationFilter::new().with_lt(under)),
("lte-", DurationFilter::new().with_lte(under)),
]);
assert!(
crossed.is_empty(),
"these slots let an unstorable operand through: {crossed:?}"
);
}
#[test]
fn a_membership_slot_refuses_the_whole_filter_for_one_element() {
let over = CEILING + SignedDuration::from_nanos(1);
let under = FLOOR - SignedDuration::from_nanos(1);
let one = SignedDuration::from_secs(1);
let crossed = leaked([
("in+", DurationFilter::new().with_in_([one, over, one])),
(
"notIn+",
DurationFilter::new().with_not_in([one, over, one]),
),
("in-", DurationFilter::new().with_in_([one, under, one])),
(
"notIn-",
DurationFilter::new().with_not_in([one, under, one]),
),
]);
assert!(
crossed.is_empty(),
"these slots dropped an unstorable element instead of refusing the filter: {crossed:?}"
);
let crossed = MongoDurationComparison::<i64>::try_from_filter(
DurationFilter::new().with_in_([FLOOR, one, CEILING]),
)
.expect("every element is storable");
assert_eq!(
crossed.in_(),
Some(&[i64::MIN, 1_000_000_000, i64::MAX][..])
);
}
#[test]
fn an_empty_membership_list_is_the_operator_present() {
let empty = MongoDurationComparison::<i64>::try_from_filter(
DurationFilter::new().with_in_(Vec::<SignedDuration>::new()),
)
.expect("no operand is no refusal");
assert_eq!(empty.conjuncts(), 1);
assert_eq!(rendered(&empty, "len"), doc! { "len": { "$in": [] } });
let absent = MongoDurationComparison::<i64>::new();
assert!(absent.is_empty());
assert!(rendered(&absent, "len").is_empty());
}
#[test]
fn the_codegen_projection_resolves_for_a_duration_field() {
type Crossed = <DurationFilter as ToDatabaseComparison<i64, Mongo>>::Comparison;
let comparison: Crossed = MongoDurationComparison::<i64>::new();
assert!(comparison.is_empty());
}
#[test]
fn a_declared_carrier_brings_its_own_ceiling() {
use bson::{Binary, spec::BinarySubtype};
use crate::BeU64;
fn wide_nanos(value: SignedDuration) -> Result<BeU64, DurationOutOfRange> {
u64::try_from(value.as_nanos())
.map(BeU64)
.map_err(|_| DurationOutOfRange)
}
let over_i64 = CEILING + SignedDuration::from_nanos(1);
let crossed = MongoDurationComparison::<BeU64>::try_from_filter_with(
DurationFilter::new().with_gt(over_i64),
wide_nanos,
)
.expect("292 years fits a u64 of nanoseconds");
assert_eq!(
rendered(&crossed, "len"),
doc! {
"len": {
"$gt": Binary {
subtype: BinarySubtype::Generic,
bytes: BeU64(9_223_372_036_854_775_808).to_blob().to_vec(),
},
}
}
);
let u64_ceiling = SignedDuration::new(18_446_744_073, 709_551_615);
assert_eq!(u64::try_from(u64_ceiling.as_nanos()), Ok(u64::MAX));
assert_eq!(
MongoDurationComparison::<BeU64>::try_from_filter_with(
DurationFilter::new().with_gt(u64_ceiling + SignedDuration::from_nanos(1)),
wide_nanos,
)
.unwrap_err(),
DurationOutOfRange
);
let negative = SignedDuration::from_secs(-1);
assert_eq!(
MongoDurationComparison::<i64>::try_from_filter(DurationFilter::new().with_gt(negative))
.expect("the default carrier is signed")
.gt(),
Some(&-1_000_000_000)
);
assert_eq!(
MongoDurationComparison::<BeU64>::try_from_filter_with(
DurationFilter::new().with_gt(negative),
wide_nanos,
)
.unwrap_err(),
DurationOutOfRange
);
}