use crate::{ComplexComparison, Nullable, ScalarFilter, TryFromFilter};
use sqlx::Sqlite;
use super::{LanguageIdCrossingError, SqlLanguageIdComparison};
use crate::primitives::lang::{Language, LanguageId, LanguageIdFilter, Region, ScriptSubtag};
type Crossed = SqlLanguageIdComparison<Sqlite>;
fn tag(sent: &str) -> LanguageId {
LanguageId::new(sent).unwrap_or_else(|refused| panic!("`{sent}` is a language tag: {refused}"))
}
fn crossed(filter: LanguageIdFilter) -> Crossed {
Crossed::try_from_filter(filter).expect("the crossing")
}
#[test]
fn an_empty_filter_crosses_to_an_empty_comparison() {
let empty = LanguageIdFilter::new();
assert!(empty.is_empty());
let comparison = crossed(empty);
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 0);
assert_eq!(comparison.members(), None);
assert_eq!(comparison.excluded(), None);
}
#[test]
fn a_whole_equality_reaches_every_seat_including_the_absent_ones() {
let comparison = crossed(LanguageIdFilter::new().with_eq(tag("de")));
assert_eq!(comparison.language().eq().map(String::as_str), Some("de"));
assert_eq!(comparison.script().null(), Some(true));
assert_eq!(comparison.region().null(), Some(true));
assert_eq!(comparison.rest().null(), Some(true));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 4);
let comparison = crossed(LanguageIdFilter::new().with_eq(tag("zh-Hans-CN")));
assert_eq!(comparison.language().eq().map(String::as_str), Some("zh"));
assert_eq!(
comparison.script().inner().eq().map(String::as_str),
Some("Hans")
);
assert_eq!(
comparison.region().inner().eq().map(String::as_str),
Some("CN")
);
assert_eq!(comparison.script().null(), None);
assert_eq!(comparison.rest().null(), Some(true));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 4);
}
#[test]
fn the_identity_axis_is_what_fills_the_tail_column() {
let bare = crossed(LanguageIdFilter::new().with_eq(tag("en-US")));
assert_eq!(bare.rest().null(), Some(true));
let tailed = crossed(LanguageIdFilter::new().with_eq(tag("en-US-x-Foo")));
assert_eq!(tailed.rest().null(), None);
assert_eq!(
tailed.rest().inner().eq().map(String::as_str),
Some("x-Foo"),
"verbatim, case included"
);
}
#[test]
fn a_component_filter_reaches_its_own_column_and_no_other() {
let chinese = LanguageIdFilter::new()
.with_language(ScalarFilter::new().with_eq(Language::new("zh").expect("a language")));
let comparison = crossed(chinese);
assert_eq!(comparison.language().eq().map(String::as_str), Some("zh"));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 1);
assert_eq!(
comparison.script().null(),
None,
"nothing was said about it"
);
assert_eq!(comparison.rest().null(), None);
let undeclared =
LanguageIdFilter::new().with_script(Nullable::new(ScalarFilter::new()).with_null(true));
let comparison = crossed(undeclared);
assert_eq!(comparison.script().null(), Some(true));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 1);
let both = LanguageIdFilter::new()
.with_language(ScalarFilter::new().with_eq(Language::new("zh").expect("a language")))
.with_script(Nullable::new(ScalarFilter::new()).with_null(true));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&crossed(both)), 2);
}
#[test]
fn a_membership_is_one_conjunct_whatever_its_width() {
for width in [0usize, 1, 2, 8] {
let operands: Vec<LanguageId> = ["de", "zh-Hans", "en-US", "fr", "ja", "ko", "it", "pt"]
.iter()
.take(width)
.map(|sent| tag(sent))
.collect();
let comparison = crossed(LanguageIdFilter::new().with_in_(operands));
assert_eq!(comparison.members(), Some(width));
assert_eq!(
ComplexComparison::<Sqlite>::conjuncts(&comparison),
1,
"width {width}"
);
}
}
#[test]
fn the_two_exclusions_merge_into_one_predicate() {
let single = crossed(LanguageIdFilter::new().with_ne(tag("de")));
assert_eq!(single.excluded(), Some(1));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&single), 1);
let list = crossed(LanguageIdFilter::new().with_not_in(vec![tag("de"), tag("fr")]));
assert_eq!(list.excluded(), Some(2));
let both = crossed(
LanguageIdFilter::new()
.with_ne(tag("ja"))
.with_not_in(vec![tag("de"), tag("fr")]),
);
assert_eq!(both.excluded(), Some(3), "the union, in one predicate");
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&both), 1);
}
#[test]
fn an_inclusion_and_an_exclusion_are_separate_conjuncts() {
let comparison = crossed(
LanguageIdFilter::new()
.with_in_(vec![tag("de"), tag("fr")])
.with_not_in(vec![tag("fr")]),
);
assert_eq!(comparison.members(), Some(2));
assert_eq!(comparison.excluded(), Some(1));
assert_eq!(ComplexComparison::<Sqlite>::conjuncts(&comparison), 2);
}
#[test]
fn naming_one_columns_value_twice_is_refused_by_name() {
let language = LanguageIdFilter::new()
.with_eq(tag("de-DE"))
.with_language(ScalarFilter::new().with_eq(Language::new("de").expect("a language")));
assert_eq!(
Crossed::try_from_filter(language),
Err(LanguageIdCrossingError::LanguageConflict)
);
let script = LanguageIdFilter::new()
.with_eq(tag("zh-Hans"))
.with_script(Nullable::new(
ScalarFilter::new().with_eq(ScriptSubtag::new("Hans").expect("a script")),
));
assert_eq!(
Crossed::try_from_filter(script),
Err(LanguageIdCrossingError::ScriptConflict)
);
let null = LanguageIdFilter::new()
.with_eq(tag("de"))
.with_script(Nullable::new(ScalarFilter::new()).with_null(true));
assert_eq!(
Crossed::try_from_filter(null),
Err(LanguageIdCrossingError::ScriptConflict)
);
let region = LanguageIdFilter::new()
.with_eq(tag("de-DE"))
.with_region(Nullable::new(
ScalarFilter::new().with_eq(Region::new("DE").expect("a region")),
));
assert_eq!(
Crossed::try_from_filter(region),
Err(LanguageIdCrossingError::RegionConflict)
);
}
#[test]
fn a_membership_beside_a_whole_equality_is_allowed() {
let filter =
LanguageIdFilter::new()
.with_eq(tag("de-DE"))
.with_language(ScalarFilter::new().with_in_(vec![
Language::new("de").expect("a language"),
Language::new("fr").expect("a language"),
]));
let comparison = crossed(filter);
assert_eq!(comparison.language().eq().map(String::as_str), Some("de"));
assert_eq!(comparison.language().in_().map(<[String]>::len), Some(2));
assert_eq!(
ComplexComparison::<Sqlite>::conjuncts(&comparison),
5,
"two on the language column, one on each of the other three"
);
}
#[cfg(feature = "postgres")]
#[test]
fn the_crossing_is_the_same_for_every_dialect() {
let filter = LanguageIdFilter::new().with_eq(tag("zh-Hans"));
let sqlite = SqlLanguageIdComparison::<Sqlite>::try_from_filter(filter.clone()).expect("crossed");
let postgres =
SqlLanguageIdComparison::<sqlx::Postgres>::try_from_filter(filter).expect("crossed");
assert_eq!(
sqlite.language().eq().map(String::as_str),
postgres.language().eq().map(String::as_str)
);
assert_eq!(sqlite.script().null(), postgres.script().null());
}