use crate::{ColumnKind, ColumnShape, CursorValue, width};
#[cfg(feature = "sqlx")]
use super::assembled;
use super::{LANGUAGE, REGION, REST, SCRIPT, SEGMENTS};
use crate::primitives::lang::LanguageId;
fn admitted(sent: &str) -> LanguageId {
LanguageId::new(sent).unwrap_or_else(|refused| panic!("`{sent}` is a language tag: {refused}"))
}
#[test]
fn the_width_is_four_plain_columns_named_for_the_seats() {
assert_eq!(SEGMENTS.len(), 4);
assert_eq!(<LanguageId as ColumnKind>::SEGMENTS, SEGMENTS);
assert_eq!(width(SEGMENTS), 4);
let names: Vec<&str> = SEGMENTS
.iter()
.map(|segment| {
segment
.field()
.expect("a plain column names its field")
.stored()
.as_str()
})
.collect();
assert_eq!(names, ["language", "script", "region", "rest"]);
assert!(
SEGMENTS
.iter()
.all(|segment| matches!(segment, ColumnShape::Plain(_))),
);
assert_eq!(LANGUAGE.as_str(), "language");
assert_eq!(SCRIPT.as_str(), "script");
assert_eq!(REGION.as_str(), "region");
assert_eq!(REST.as_str(), "rest");
}
#[cfg(feature = "sqlx")]
#[test]
fn four_columns_assemble_into_the_identity_they_came_from() {
for tag in [
"de",
"de-DE",
"zh-Hans",
"sr-Cyrl-RS",
"en-US-x-Foo",
"zh-yue-Hant-HK",
] {
let held = admitted(tag);
let round_tripped = assembled(
held.language().as_str(),
held.script().map(|script| script.as_str()),
held.region().map(|region| region.as_str()),
held.rest().map(|rest| rest.as_str()),
)
.expect("the columns a write path produced");
assert_eq!(round_tripped, held, "`{tag}`");
}
}
#[cfg(feature = "sqlx")]
#[test]
fn columns_written_by_somebody_else_read_back_canonical() {
let foreign = assembled("GER", Some("latn"), Some("de"), None).expect("a decode");
assert_eq!(foreign, admitted("de-DE"));
assert_eq!(
foreign.script(),
None,
"the suppression fired at the decode"
);
}
#[cfg(feature = "sqlx")]
#[test]
fn a_column_holding_something_else_refuses_to_decode() {
assert!(assembled("!!", None, None, None).is_err());
assert!(assembled("", None, None, None).is_err());
assert!(assembled("de", Some("Latin"), None, None).is_err());
assert!(assembled("de", None, Some("DEU"), None).is_err());
assert!(assembled("de", None, None, Some("x-!!")).is_err());
assert_eq!(
assembled("en", Some("Latn"), None, None).expect("a decode"),
admitted("en")
);
}
#[cfg(feature = "sqlx")]
#[test]
fn a_garbage_column_cannot_land_in_a_seat_it_did_not_come_from() {
assert!(
assembled("de", Some("US"), None, None).is_err(),
"a rebuilt tag would have read this as a region"
);
assert!(
assembled("de", Some("Latin"), None, None).is_err(),
"a rebuilt tag would have carried this as a variant"
);
let held = assembled("de", Some("Latn"), Some("US"), None).expect("a decode");
assert_eq!(held.region().map(|region| region.as_str()), Some("US"));
assert_eq!(held.script(), None, "German implies Latin");
}
#[test]
fn the_keyset_position_round_trips_and_refuses_a_forgery() {
for tag in ["de", "zh-Hans-CN", "en-US-x-Foo", "sr-Cyrl-RS"] {
let held = admitted(tag);
let mut position = Vec::new();
held.write_cursor(&mut position);
assert_eq!(position, tag.as_bytes(), "`{tag}`");
assert_eq!(LanguageId::read_cursor(&position), Some(held), "`{tag}`");
}
let folded = admitted("GER-latn-de");
let mut position = Vec::new();
folded.write_cursor(&mut position);
assert_eq!(position, b"de-DE");
assert_eq!(
LanguageId::read_cursor(b"en--US"),
None,
"a forged position"
);
assert_eq!(LanguageId::read_cursor(b""), None);
assert_eq!(LanguageId::read_cursor(&[0xff]), None, "not even UTF-8");
}
#[cfg(feature = "mongo")]
#[test]
fn an_identity_carries_as_a_sub_document_of_its_four_seats() {
use crate::MongoCarrier;
use bson::Bson;
let bson::Bson::Document(carried) = admitted("zh-Hans-CN").to_bson() else {
panic!("an identity carries as a sub-document");
};
let keys: Vec<&str> = carried.keys().map(String::as_str).collect();
assert_eq!(
keys,
[
LANGUAGE.as_str(),
SCRIPT.as_str(),
REGION.as_str(),
REST.as_str()
],
"the four segments, in the seats' own order and nothing beside them",
);
assert_eq!(carried.get(LANGUAGE.as_str()), Some(&Bson::from("zh")));
assert_eq!(carried.get(SCRIPT.as_str()), Some(&Bson::from("Hans")));
assert_eq!(carried.get(REGION.as_str()), Some(&Bson::from("CN")));
assert_eq!(carried.get(REST.as_str()), Some(&Bson::Null));
assert_eq!(
admitted("GER-latn-de").to_bson(),
admitted("de-DE").to_bson()
);
let bson::Bson::Document(bare) = admitted("de").to_bson() else {
panic!("an identity carries as a sub-document");
};
assert_eq!(bare.len(), 4, "four keys, however few seats are filled");
for absent in [SCRIPT, REGION, REST] {
let absent = absent.as_str();
assert_eq!(bare.get(absent), Some(&Bson::Null), "{absent}");
}
let bson::Bson::Document(tailed) = admitted("en-US-x-Foo").to_bson() else {
panic!("an identity carries as a sub-document");
};
assert_eq!(tailed.get(REST.as_str()), Some(&Bson::from("x-Foo")));
}
#[cfg(feature = "mongo")]
#[test]
fn an_identity_reads_back_the_document_it_carried_as() {
use crate::{MongoCarrier, query::mongo::MongoExtract};
for tag in [
"de",
"de-DE",
"zh-Hans",
"zh-Hans-CN",
"sr-Cyrl-RS",
"en-US-x-Foo",
"zh-yue-Hant-HK",
] {
let held = admitted(tag);
let written = held.to_bson();
assert_eq!(LanguageId::extract(Some(&written)), Ok(held), "`{tag}`");
}
}
#[cfg(feature = "mongo")]
#[test]
fn a_missing_or_null_language_key_is_one_named_refusal() {
use crate::query::mongo::{MongoExtract, MongoTypeError};
use bson::doc;
let missing = doc! { "script": "Hans", "region": "CN", "rest": bson::Bson::Null };
let null = doc! {
"language": bson::Bson::Null, "script": "Hans", "region": "CN", "rest": bson::Bson::Null
};
let refusal = LanguageId::extract(Some(&missing.into()));
assert!(
matches!(refusal, Err(MongoTypeError::Range(_))),
"a missing language key: {refusal:?}"
);
assert_eq!(
refusal,
LanguageId::extract(Some(&null.into())),
"a missing key and an explicit null name the SAME refusal for this seat",
);
}
#[cfg(feature = "mongo")]
#[test]
fn a_missing_optional_seat_and_an_explicit_null_both_read_as_absent() {
use crate::query::mongo::MongoExtract;
use bson::doc;
let missing_script =
doc! { "language": "de", "region": bson::Bson::Null, "rest": bson::Bson::Null };
let null_script = doc! {
"language": "de", "script": bson::Bson::Null, "region": bson::Bson::Null,
"rest": bson::Bson::Null
};
let from_missing = LanguageId::extract(Some(&missing_script.into())).expect("a bare `de`");
let from_null = LanguageId::extract(Some(&null_script.into())).expect("a bare `de`");
assert_eq!(from_missing, admitted("de"));
assert_eq!(
from_missing, from_null,
"a missing key and an explicit null are one answer"
);
assert_eq!(from_missing.script(), None);
}
#[cfg(feature = "mongo")]
#[test]
fn a_wrong_bson_type_at_a_seat_is_named() {
use crate::query::mongo::{MongoExtract, MongoTypeError};
use bson::doc;
let document = doc! {
"language": "de", "script": 4i32, "region": bson::Bson::Null, "rest": bson::Bson::Null
};
assert_eq!(
LanguageId::extract(Some(&document.into())),
Err(MongoTypeError::wrong_type("string", "int"))
);
assert_eq!(
LanguageId::extract(Some(&bson::Bson::String(String::from("de")))),
Err(MongoTypeError::wrong_type("object", "string"))
);
assert_eq!(LanguageId::extract(None), Err(MongoTypeError::Absent));
}
#[cfg(feature = "mongo")]
#[test]
fn a_hand_written_document_folds_at_the_read_door_too() {
use crate::query::mongo::MongoExtract;
use bson::doc;
let foreign = doc! {
"language": "GER", "script": "latn", "region": "de", "rest": bson::Bson::Null
};
let read = LanguageId::extract(Some(&foreign.into())).expect("a decode");
assert_eq!(read, admitted("de-DE"));
assert_eq!(read.script(), None, "the suppression fired at the read");
}
#[cfg(feature = "mongo")]
#[test]
fn a_malformed_tail_is_refused_rather_than_carried() {
use crate::query::mongo::{MongoExtract, MongoTypeError};
use bson::doc;
let document = doc! {
"language": "en", "script": bson::Bson::Null, "region": bson::Bson::Null, "rest": "x-!!"
};
assert!(matches!(
LanguageId::extract(Some(&document.into())),
Err(MongoTypeError::Range(_))
));
}