use bson::{Document, doc};
use super::{MongoPipeline, address, ordered, ordered_with, scan};
use crate::{
Cursor, FieldName, OrderDirection, OrderTerm, TermName, Walk,
comparison::mongo::{Mongo, MongoLoweringError},
query::{
DEPTH_CEILING, Unpushable,
mongo::{
MongoKeyset, MongoOrder, MongoQueryError,
tests::{
DeepSubjects, ShotCursor, ShotFilter, ShotMongo, ShotOrder, by_cover_title, covering,
subjects, terms, titled,
},
},
partition,
},
};
fn matched() -> Document {
doc! { "$match": { "title": { "$eq": "a red car" } } }
}
#[test]
fn an_unordered_scan_is_one_match_stage() {
let filter = titled("a red car");
let package = scan::<ShotMongo>(Some(&filter), None).expect("the filter lowers");
assert_eq!(package.collection(), FieldName::new("shot"));
assert_eq!(package.pipeline(), [matched()]);
}
#[test]
fn an_unfiltered_scan_still_writes_its_match() {
let package = scan::<ShotMongo>(None, None).expect("nothing to lower");
assert_eq!(package.pipeline(), [doc! { "$match": {} }]);
}
#[test]
fn a_ceiling_adds_a_limit_and_no_sort() {
let filter = titled("a red car");
let package = scan::<ShotMongo>(Some(&filter), Some(25)).expect("the filter lowers");
assert_eq!(package.pipeline(), [matched(), doc! { "$limit": 25i64 }]);
}
#[test]
fn an_ordered_scan_is_a_match_and_a_sort() {
let filter = titled("a red car");
let terms = terms(&[ShotOrder::Title(OrderDirection::Asc)]);
let order = MongoOrder::new(&terms).expect("two terms");
let package =
ordered::<ShotMongo, ShotCursor>(Some(&filter), order, None, Walk::Forward, None, None)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[matched(), doc! { "$sort": { "title": 1, "_id": 1 } }]
);
}
#[test]
fn the_first_page_is_match_sort_limit() {
let filter = titled("a red car");
let terms = terms(&[ShotOrder::Title(OrderDirection::Asc)]);
let order = MongoOrder::new(&terms).expect("two terms");
let package =
ordered::<ShotMongo, ShotCursor>(Some(&filter), order, None, Walk::Forward, Some(3), None)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[
matched(),
doc! { "$sort": { "title": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
}
#[test]
fn the_second_page_folds_the_keyset_into_the_same_match() {
let filter = titled("a red car");
let terms = terms(&[ShotOrder::Title(OrderDirection::Asc)]);
let order = MongoOrder::new(&terms).expect("two terms");
let cursor = Cursor::at(
&terms,
vec![
Some(ShotCursor::Title("a red car".to_owned())),
Some(ShotCursor::Id(12)),
],
);
let keyset = MongoKeyset::resume(order, &cursor, Walk::Forward).expect("this order's cursor");
let package = ordered::<ShotMongo, ShotCursor>(
Some(&filter),
order,
Some(&keyset),
Walk::Forward,
Some(3),
None,
)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[
doc! {
"$match": {
"title": { "$eq": "a red car" },
"$and": [ {
"$or": [
{ "title": { "$gt": "a red car" } },
{ "title": { "$eq": "a red car" }, "_id": { "$gt": 12i64 } },
]
} ],
}
},
doc! { "$sort": { "title": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
}
#[test]
fn an_offset_page_skips_before_it_limits() {
let terms = terms(&[]);
let order = MongoOrder::new(&terms).expect("the id tail");
let package =
ordered::<ShotMongo, ShotCursor>(None, order, None, Walk::Forward, Some(3), Some(40))
.expect("nothing to lower");
assert_eq!(
package.pipeline(),
[
doc! { "$match": {} },
doc! { "$sort": { "_id": 1 } },
doc! { "$skip": 40i64 },
doc! { "$limit": 3i64 },
]
);
}
#[test]
fn a_skip_past_the_ceiling_is_refused() {
let terms = terms(&[]);
let order = MongoOrder::new(&terms).expect("the id tail");
let refused =
ordered::<ShotMongo, ShotCursor>(None, order, None, Walk::Forward, Some(3), Some(u64::MAX));
assert!(matches!(refused, Err(MongoQueryError::Skip(u64::MAX))));
}
#[test]
fn an_address_is_one_match_on_the_underscore_id() {
let package = address::<ShotMongo>(&12).expect("the id crosses");
assert_eq!(package.collection(), FieldName::new("shot"));
assert_eq!(
package.pipeline(),
[doc! { "$match": { "_id": { "$eq": 12i64 } } }]
);
}
#[test]
fn a_flat_package_reads_one_collection() {
let package = scan::<ShotMongo>(None, None).expect("nothing to lower");
assert_eq!(package.reads(), [FieldName::new("shot")]);
assert!(!package.spans_collections());
}
#[test]
fn a_relation_joins_before_the_sort_and_grows_the_reads() {
let filter = covering("Autumn");
let terms = terms(&[ShotOrder::Title(OrderDirection::Asc)]);
let order = MongoOrder::new(&terms).expect("two terms");
let package =
ordered::<ShotMongo, ShotCursor>(Some(&filter), order, None, Walk::Forward, Some(3), None)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[
doc! { "$match": {} },
doc! { "$lookup": {
"from": "keyframe",
"localField": "cover_id",
"foreignField": "_id",
"as": "__ig_keyframe_1__",
"pipeline": [ { "$match": { "title": { "$eq": "Autumn" } } } ],
} },
doc! { "$match": { "__ig_keyframe_1__": { "$ne": [] } } },
doc! { "$project": { "__ig_keyframe_1__": 0 } },
doc! { "$sort": { "title": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
assert_eq!(
package.reads(),
[FieldName::new("shot"), FieldName::new("keyframe")]
);
assert!(
package.spans_collections(),
"a joined package runs under the snapshot concern"
);
}
#[test]
fn an_unasked_relation_position_neither_joins_nor_spans() {
let package = scan::<ShotMongo>(Some(&titled("a red car")), None).expect("the filter lowers");
assert_eq!(package.pipeline(), [matched()]);
assert_eq!(package.reads(), [FieldName::new("shot")]);
assert!(!package.spans_collections());
}
#[test]
fn a_package_over_two_collections_spans_them() {
let package = MongoPipeline::new(
FieldName::new("shot"),
vec![doc! { "$match": {} }, doc! { "$unionWith": "keyframe" }],
vec![FieldName::new("shot"), FieldName::new("keyframe")],
);
assert_eq!(package.reads().len(), 2);
assert!(package.spans_collections());
}
#[test]
fn a_nested_first_page_joins_before_it_matches() {
let filter = titled("a red car");
let written = by_cover_title();
let terms = terms(&written);
let subjects = subjects(&written);
let order = MongoOrder::new(&terms).expect("two terms");
let package = ordered_with::<ShotMongo, ShotCursor, _>(
Some(&filter),
order,
None,
Walk::Forward,
Some(3),
None,
&subjects,
)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[
doc! { "$lookup": {
"from": "keyframe",
"localField": "cover_id",
"foreignField": "_id",
"as": "__ig_keyframe_1__",
} },
doc! { "$addFields": { "__ig_ord0__": { "$first": "$__ig_keyframe_1__.title" } } },
doc! { "$project": { "__ig_keyframe_1__": 0 } },
matched(),
doc! { "$sort": { "__ig_ord0__": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
}
#[test]
fn a_nested_second_page_resumes_on_the_materialized_field() {
let written = by_cover_title();
let terms = terms(&written);
let subjects = subjects(&written);
let order = MongoOrder::new(&terms).expect("two terms");
let cursor = Cursor::at(
&terms,
vec![
Some(ShotCursor::CoverTitle("Autumn".to_owned())),
Some(ShotCursor::Id(12)),
],
);
let keyset = MongoKeyset::resume_with(order, &cursor, Walk::Forward, &subjects)
.expect("this order's cursor");
let package = ordered_with::<ShotMongo, ShotCursor, _>(
None,
order,
Some(&keyset),
Walk::Forward,
Some(3),
None,
&subjects,
)
.expect("nothing to lower");
assert_eq!(
package.pipeline(),
[
doc! { "$lookup": {
"from": "keyframe",
"localField": "cover_id",
"foreignField": "_id",
"as": "__ig_keyframe_1__",
} },
doc! { "$addFields": { "__ig_ord0__": { "$first": "$__ig_keyframe_1__.title" } } },
doc! { "$project": { "__ig_keyframe_1__": 0 } },
doc! { "$match": {
"$and": [ {
"$or": [
{ "__ig_ord0__": { "$gt": "Autumn" } },
{ "__ig_ord0__": { "$eq": "Autumn" }, "_id": { "$gt": 12i64 } },
]
} ],
} },
doc! { "$sort": { "__ig_ord0__": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
}
#[test]
fn a_nested_package_reads_the_collection_it_joined() {
let written = by_cover_title();
let terms = terms(&written);
let subjects = subjects(&written);
let order = MongoOrder::new(&terms).expect("two terms");
let package = ordered_with::<ShotMongo, ShotCursor, _>(
None,
order,
None,
Walk::Forward,
None,
None,
&subjects,
)
.expect("nothing to lower");
assert_eq!(
package.reads(),
[FieldName::new("shot"), FieldName::new("keyframe")]
);
assert!(package.spans_collections());
}
#[test]
fn a_flat_order_through_the_subjects_builder_still_reads_one_collection() {
let terms = terms(&[ShotOrder::Title(OrderDirection::Asc)]);
let order = MongoOrder::new(&terms).expect("two terms");
let package = ordered::<ShotMongo, ShotCursor>(None, order, None, Walk::Forward, None, None)
.expect("nothing to lower");
assert_eq!(package.reads(), [FieldName::new("shot")]);
assert!(!package.spans_collections());
}
#[test]
fn a_nested_order_past_the_ceiling_refuses_the_package() {
let terms = terms(&by_cover_title());
let order = MongoOrder::new(&terms).expect("two terms");
let refused = ordered_with::<ShotMongo, ShotCursor, _>(
None,
order,
None,
Walk::Forward,
None,
None,
&DeepSubjects::crossing(DEPTH_CEILING),
);
assert!(matches!(
refused,
Err(MongoQueryError::Lowering(MongoLoweringError::RelationDepth(depth)))
if depth.table() == FieldName::new("shot") && depth.ceiling() == DEPTH_CEILING
));
}
#[test]
fn a_package_gives_its_stages_up() {
let package = scan::<ShotMongo>(None, Some(5)).expect("nothing to lower");
let stages = package.into_pipeline();
assert_eq!(stages, [doc! { "$match": {} }, doc! { "$limit": 5i64 }]);
}
#[test]
fn the_filter_is_the_records_own_comparison() {
let filter: ShotFilter = titled("a red car");
let package = scan::<ShotMongo>(Some(&filter), None).expect("the filter lowers");
assert_eq!(package.pipeline(), [matched()]);
}
#[test]
fn a_relation_and_a_nested_order_into_one_collection_do_not_hold_one_name_twice() {
let filter = covering("Autumn");
let written = by_cover_title();
let terms = terms(&written);
let subjects = subjects(&written);
let order = MongoOrder::new(&terms).expect("two terms");
let package = ordered_with::<ShotMongo, ShotCursor, _>(
Some(&filter),
order,
None,
Walk::Forward,
Some(3),
None,
&subjects,
)
.expect("the filter lowers");
assert_eq!(
package.pipeline(),
[
doc! { "$lookup": {
"from": "keyframe",
"localField": "cover_id",
"foreignField": "_id",
"as": "__ig_keyframe_1__",
} },
doc! { "$addFields": { "__ig_ord0__": { "$first": "$__ig_keyframe_1__.title" } } },
doc! { "$project": { "__ig_keyframe_1__": 0 } },
doc! { "$match": {} },
doc! { "$lookup": {
"from": "keyframe",
"localField": "cover_id",
"foreignField": "_id",
"as": "__ig_keyframe_1__",
"pipeline": [ { "$match": { "title": { "$eq": "Autumn" } } } ],
} },
doc! { "$match": { "__ig_keyframe_1__": { "$ne": [] } } },
doc! { "$project": { "__ig_keyframe_1__": 0 } },
doc! { "$sort": { "__ig_ord0__": 1, "_id": 1 } },
doc! { "$limit": 3i64 },
]
);
assert_eq!(
package.reads(),
[FieldName::new("shot"), FieldName::new("keyframe")]
);
assert!(package.spans_collections());
}
fn repeated() -> [OrderTerm; 3] {
[
OrderTerm::new(
TermName::new("title"),
FieldName::new("title"),
OrderDirection::Asc,
),
OrderTerm::new(
TermName::new("caption"),
FieldName::new("title"),
OrderDirection::Desc,
),
OrderTerm::new(
TermName::new("id"),
FieldName::new("id"),
OrderDirection::Asc,
),
]
}
#[derive(Debug)]
struct Returned {
title: &'static str,
id: i64,
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
enum Sortable {
Text(&'static str),
Number(i64),
}
#[test]
fn a_repeated_order_degrades_into_a_prefix_sort_and_a_memory_completion() {
let written = repeated();
let split = partition::<Mongo>(&written);
assert_eq!(split.cause(), Some(Unpushable::Repetition));
assert!(
MongoOrder::new(&written).is_err(),
"the whole order has no `$sort` — which is the backstop, not the plan"
);
let order = MongoOrder::new(split.pushable()).expect("the frame's own prefix");
let package = ordered::<ShotMongo, ShotCursor>(None, order, None, Walk::Forward, None, None)
.expect("nothing to lower");
assert_eq!(
package.pipeline(),
[doc! { "$match": {} }, doc! { "$sort": { "title": 1 } }]
);
let mut returned = vec![
Returned {
title: "alpha",
id: 3,
},
Returned {
title: "alpha",
id: 1,
},
Returned {
title: "beta",
id: 2,
},
];
split.apply(&mut returned, |row, term| match term.column().as_ref() {
"title" => Some(Sortable::Text(row.title)),
_ => Some(Sortable::Number(row.id)),
});
assert_eq!(
returned.iter().map(|row| row.id).collect::<Vec<_>>(),
[1, 3, 2]
);
}
#[test]
fn a_page_over_a_degraded_order_is_refused_and_not_completed() {
let written = repeated();
let split = partition::<Mongo>(&written);
let refusal = split
.paging::<Mongo>()
.expect_err("a page's order is the statement's");
assert_eq!(refusal.term(), TermName::new("caption"));
assert_eq!(refusal.cause(), Unpushable::Repetition);
let cursor = Cursor::at(
&written,
vec![
Some(ShotCursor::Title("alpha".to_owned())),
Some(ShotCursor::Title("alpha".to_owned())),
Some(ShotCursor::Id(12)),
],
);
let order = MongoOrder::new(split.pushable()).expect("the frame's own prefix");
assert!(
MongoKeyset::resume(order, &cursor, Walk::Forward).is_err(),
"a cursor minted under the whole order is not the prefix's"
);
}