use smol_bytes::Utf8Bytes;
use super::{Language, Region, ScriptSubtag};
#[cfg(feature = "mongo")]
#[test]
fn a_subtag_carries_as_the_canonical_word() {
use crate::MongoCarrier;
use bson::Bson;
assert_eq!(
Language::new("de").unwrap().to_bson(),
Bson::String(String::from("de"))
);
assert_eq!(
ScriptSubtag::new("Hans").unwrap().to_bson(),
Bson::String(String::from("Hans"))
);
assert_eq!(
Region::new("419").unwrap().to_bson(),
Bson::String(String::from("419")),
"a numeric region is a STRING and never a BSON number — the leading-zero argument the wire \
door makes, one layer down",
);
for (sent, canonical) in [("GER", "de"), ("deu", "de"), ("iw", "he"), ("DE", "de")] {
assert_eq!(
Language::new(sent).unwrap().to_bson(),
Language::new(canonical).unwrap().to_bson(),
"`{sent}` and `{canonical}` reach one document",
);
}
assert_eq!(
ScriptSubtag::new("latn").unwrap().to_bson(),
Bson::String(String::from(ScriptSubtag::new("Latn").unwrap().as_str())),
);
}
#[cfg(feature = "mongo")]
#[test]
fn a_subtag_reads_back_the_document_it_carried_as() {
use crate::{MongoCarrier, query::mongo::MongoExtract};
for sent in ["de", "ger", "iw", "und"] {
let language = Language::new(sent).unwrap();
let written = language.to_bson();
assert_eq!(Language::extract(Some(&written)), Ok(language), "`{sent}`");
}
for sent in ["Hans", "latn", "Hant"] {
let script = ScriptSubtag::new(sent).unwrap();
let written = script.to_bson();
assert_eq!(
ScriptSubtag::extract(Some(&written)),
Ok(script),
"`{sent}`"
);
}
for sent in ["DE", "419", "bu"] {
let region = Region::new(sent).unwrap();
let written = region.to_bson();
assert_eq!(Region::extract(Some(&written)), Ok(region), "`{sent}`");
}
}
#[cfg(feature = "mongo")]
#[test]
fn a_subtag_read_refuses_absence_and_the_wrong_type_by_name() {
use crate::query::mongo::{MongoExtract, MongoTypeError};
use bson::Bson;
assert_eq!(Language::extract(None), Err(MongoTypeError::Absent));
assert_eq!(
Language::extract(Some(&Bson::Null)),
Err(MongoTypeError::wrong_type("string", "null"))
);
assert_eq!(
ScriptSubtag::extract(Some(&Bson::Int32(4))),
Err(MongoTypeError::wrong_type("string", "int")),
"the alias NAMES what was found rather than spelling `not a string`",
);
assert_eq!(
Region::extract(Some(&Bson::Document(bson::doc! {}))),
Err(MongoTypeError::wrong_type("string", "object"))
);
}
#[cfg(feature = "mongo")]
#[test]
fn a_subtag_read_refuses_a_string_that_names_no_subtag() {
use crate::query::mongo::{MongoExtract, MongoTypeError};
use bson::Bson;
assert!(matches!(
Language::extract(Some(&Bson::String(String::from("1")))),
Err(MongoTypeError::Range(_))
));
assert!(matches!(
ScriptSubtag::extract(Some(&Bson::String(String::new()))),
Err(MongoTypeError::Range(_))
));
assert!(matches!(
Region::extract(Some(&Bson::String(String::from("ZZZZ")))),
Err(MongoTypeError::Range(_))
));
}
#[cfg(feature = "mongo")]
#[test]
fn a_hand_written_document_folds_at_the_read_door_too() {
use crate::query::mongo::MongoExtract;
use bson::Bson;
let foreign = Bson::String(String::from("GER"));
let canonical = Bson::String(String::from("de"));
assert_eq!(
Language::extract(Some(&foreign)),
Language::extract(Some(&canonical)),
"an mkv's alpha-3 spelling and the canonical one read as ONE value",
);
assert_eq!(
Language::extract(Some(&foreign)),
Ok(Language::new("de").unwrap())
);
assert_eq!(
Region::extract(Some(&Bson::String(String::from("BU")))),
Region::extract(Some(&Bson::String(String::from("MM")))),
"a deprecated region code and its preferred value read as ONE value",
);
assert_eq!(
ScriptSubtag::extract(Some(&Bson::String(String::from("hans")))),
Ok(ScriptSubtag::new("Hans").unwrap()),
);
}
#[test]
fn a_subtag_addresses_exactly_the_path_its_text_addresses() {
fn keyed<I: crate::store::Segment>(id: &I) -> Vec<String> {
let mut segments = crate::store::Segments::new();
segments.push(id);
segments.as_slice().to_vec()
}
fn delegated(word: &str) -> Vec<String> {
keyed(&Utf8Bytes::from(word))
}
assert_eq!(keyed(&Language::new("de").unwrap()), delegated("de"));
assert_eq!(
keyed(&ScriptSubtag::new("Hans").unwrap()),
delegated("Hans")
);
assert_eq!(keyed(&Region::new("DE").unwrap()), delegated("DE"));
assert_eq!(
keyed(&Language::new("ger").unwrap()),
keyed(&Language::new("de").unwrap()),
);
assert_eq!(
keyed(&Region::new("bu").unwrap()),
keyed(&Region::new("MM").unwrap()),
"the region's preferred-value fold reaches the address too",
);
}
#[test]
fn the_key_vocabulary_admits_the_three_subtags() {
const fn admits<I: crate::Id>() {}
const _: () = admits::<Language>();
const _: () = admits::<ScriptSubtag>();
const _: () = admits::<Region>();
const _: () = admits::<Utf8Bytes>();
}