use bson::{Document, doc};
use super::MongoScalarComparison;
use crate::{
At, ComplexComparison, FieldName, Mongo, RecordAddress, ScalarFilter, ToDatabaseComparison,
TryFromFilter, comparison::mongo::MongoConjunction,
};
const ROW: RecordAddress = RecordAddress::new(FieldName::new("media"), &[FieldName::new("id")]);
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 two_operators_on_one_field_share_one_key() {
let comparison =
MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_gt(1).with_lt(5))
.expect("the identity crossing cannot fail");
assert_eq!(comparison.conjuncts(), 2);
assert_eq!(
rendered(&comparison, "a"),
doc! { "a": { "$gt": 1_i64, "$lt": 5_i64 } }
);
}
#[test]
fn every_operator_maps_one_to_one_and_merges() {
let comparison = MongoScalarComparison::<i64>::try_from_filter(
ScalarFilter::<i64>::new()
.with_eq(1)
.with_ne(2)
.with_gt(3)
.with_gte(4)
.with_lt(5)
.with_lte(6)
.with_in_(vec![7_i64, 8])
.with_not_in(vec![9_i64]),
)
.expect("the identity crossing cannot fail");
assert_eq!(comparison.conjuncts(), 8);
assert_eq!(
rendered(&comparison, "a"),
doc! {
"a": {
"$eq": 1_i64,
"$ne": 2_i64,
"$gt": 3_i64,
"$gte": 4_i64,
"$lt": 5_i64,
"$lte": 6_i64,
"$in": [7_i64, 8_i64],
"$nin": [9_i64],
}
}
);
}
#[test]
fn a_frame_below_a_frame_addresses_a_subdocument() {
let comparison =
MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_eq(3))
.expect("the identity crossing cannot fail");
let outer = At::new(&ROW).frame(FieldName::new("timebase"));
let inner = outer.at().frame(FieldName::new("num"));
let filter = comparison
.apply(inner.at(), MongoConjunction::new())
.expect("a MongoDB lowering cannot refuse")
.into_document();
assert_eq!(filter, doc! { "timebase.num": { "$eq": 3_i64 } });
}
#[test]
fn an_empty_membership_list_is_the_operator_present() {
let empty = MongoScalarComparison::<i64>::try_from_filter(
ScalarFilter::<i64>::new().with_in_(Vec::<i64>::new()),
)
.expect("the identity crossing cannot fail");
assert_eq!(empty.conjuncts(), 1);
assert_eq!(rendered(&empty, "a"), doc! { "a": { "$in": [] } });
let absent = MongoScalarComparison::<i64>::new();
assert!(absent.is_empty());
assert!(rendered(&absent, "a").is_empty());
}
#[test]
fn two_comparisons_at_one_path_overflow_rather_than_overwrite() {
let first = MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_eq(1))
.expect("the identity crossing cannot fail");
let second = MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_eq(2))
.expect("the identity crossing cannot fail");
let frame = At::new(&ROW).frame(FieldName::new("a"));
let mut accumulator = MongoConjunction::new();
accumulator = first
.apply(frame.at(), accumulator)
.expect("a MongoDB lowering cannot refuse");
accumulator = second
.apply(frame.at(), accumulator)
.expect("a MongoDB lowering cannot refuse");
assert_eq!(
accumulator.into_document(),
doc! {
"a": { "$eq": 1_i64 },
"$and": [ { "a": { "$eq": 2_i64 } } ],
}
);
}
#[test]
fn a_column_comparison_at_the_top_level_writes_the_key_the_server_refuses() {
let comparison =
MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_eq(1))
.expect("the identity crossing cannot fail");
let filter = comparison
.apply(At::new(&ROW), MongoConjunction::new())
.expect("a MongoDB lowering cannot refuse")
.into_document();
assert_eq!(filter, doc! { "$": { "$eq": 1_i64 } });
}
#[test]
fn the_codegen_projection_resolves_for_a_scalar_field() {
type Crossed = <ScalarFilter<i64> as ToDatabaseComparison<i64, Mongo>>::Comparison;
let comparison: Crossed = MongoScalarComparison::<i64>::new();
assert!(comparison.is_empty());
}
#[test]
fn the_identity_crossing_cannot_fail() {
fn unreachable_reason(
error: <MongoScalarComparison<i64> as TryFromFilter<ScalarFilter<i64>>>::Error,
) -> ! {
match error {}
}
match MongoScalarComparison::<i64>::try_from_filter(ScalarFilter::<i32>::new().with_eq(1)) {
Ok(comparison) => assert_eq!(comparison.conjuncts(), 1),
Err(error) => unreachable_reason(error),
}
}
#[test]
fn a_field_operator_lowering_refuses_nothing() {
let comparison = MongoScalarComparison::<i64>::try_from_filter(
ScalarFilter::<i32>::new().with_gt(1).with_not_in([2, 3]),
)
.expect("the identity crossing");
let frame = At::new(&ROW).frame(FieldName::new("a"));
assert!(
comparison
.apply(frame.at(), MongoConjunction::new())
.is_ok()
);
let scope = comparison
.apply(At::new(&ROW), MongoConjunction::element())
.expect("apply itself never refuses")
.into_element_document();
assert_eq!(scope, Ok(doc! { "$gt": 1i64, "$nin": [ 2i64, 3i64 ] }));
}
#[test]
fn a_wide_integer_field_declares_the_big_endian_carrier() {
use bson::{Binary, spec::BinarySubtype};
use crate::BeU64;
fn blob(value: BeU64) -> Binary {
Binary {
subtype: BinarySubtype::Generic,
bytes: value.to_blob().to_vec(),
}
}
let comparison = MongoScalarComparison::<BeU64>::try_from_filter(
ScalarFilter::<u64>::new().with_eq(1_u64).with_lt(9_u64),
)
.expect("the crossing into a blob carrier is total");
assert_eq!(comparison.eq(), Some(&BeU64(1)));
assert_eq!(
rendered(&comparison, "checksum"),
doc! {
"checksum": {
"$eq": blob(BeU64(1)),
"$lt": blob(BeU64(9)),
}
}
);
}
#[test]
fn an_instant_compares_whole_under_one_key() {
use crate::Timestamp;
let at: Timestamp = "2026-08-09T21:14:03.123456789Z".parse().unwrap();
let before: Timestamp = "1969-12-31T23:59:58.5Z".parse().unwrap();
let comparison = MongoScalarComparison::<Timestamp>::try_from_filter(
ScalarFilter::<Timestamp>::new()
.with_gte(before)
.with_lt(at),
)
.expect("the identity crossing cannot fail");
let rendered = rendered(&comparison, "at");
assert_eq!(
rendered,
doc! {
"at": {
"$gte": { "secs": -1_i64, "nanos": -500_000_000_i32 },
"$lt": { "secs": 1_786_310_043_i64, "nanos": 123_456_789_i32 },
}
}
);
let Some(bson::Bson::Document(operators)) = rendered.get("at") else {
panic!("the instant's operators share one key");
};
let Some(bson::Bson::Document(operand)) = operators.get("$lt") else {
panic!("the operand is a sub-document");
};
assert_eq!(
operand.keys().collect::<Vec<_>>(),
["secs", "nanos"],
"BSON compares a document field by field in this order, so seconds have to come first"
);
}
#[test]
fn a_confidence_threshold_renders_at_the_columns_width() {
use crate::{Confidence, ConfidenceFilter, ConfidenceOperand};
let filter = ConfidenceFilter::new().with_gte(ConfidenceOperand::number(0.5).expect("in range"));
let crossed: MongoScalarComparison<Confidence<f32>> =
TryFromFilter::try_from_filter(filter).expect("f32 holds a half");
assert_eq!(crossed.gte(), Confidence::<f32>::new(0.5).as_ref());
assert_eq!(
rendered(&crossed, "score"),
doc! { "score": { "$gte": 0.5 } }
);
}