use async_graphql::{Pos, ScalarType, Value};
use crate::primitives::lang::{Language, Region, ScriptSubtag};
fn door(sent: Value) -> Result<Language, String> {
<Language as ScalarType>::parse(sent)
.map_err(|refused| refused.into_server_error(Pos::default()).message)
}
fn admitted(sent: Value) -> Language {
door(sent.clone()).unwrap_or_else(|refused| panic!("{sent} is a language: {refused}"))
}
#[test]
fn the_door_is_the_types_own_grammar() {
for (sent, canonical) in [
("de", "de"),
("DE", "de"),
("ger", "de"),
("deu", "de"),
("iw", "he"),
("und", "und"),
("xyz", "xyz"),
] {
assert_eq!(admitted(Value::from(sent)).as_str(), canonical, "`{sent}`");
}
}
#[test]
fn every_spelling_is_written_back_as_the_canonical_one() {
let canonical = Value::from("de");
for sent in ["de", "DE", "De", "ger", "GER", "deu"] {
assert_eq!(
admitted(Value::from(sent)).to_value(),
canonical,
"`{sent}`"
);
}
}
#[test]
fn a_non_string_is_refused() {
for sent in [
Value::from(419),
Value::from(1.0),
Value::Boolean(true),
Value::Null,
Value::List(vec![Value::from("de")]),
] {
assert!(door(sent.clone()).is_err(), "{sent}");
}
}
#[test]
fn a_refusal_names_the_rule_that_broke() {
let underscore = door(Value::from("zh_CN")).expect_err("an underscore is not a letter");
assert!(underscore.contains('_'), "{underscore}");
assert!(underscore.contains("letters"), "{underscore}");
let short = door(Value::from("e")).expect_err("one letter is not a subtag");
assert!(short.contains("two letters"), "{short}");
}
#[test]
fn validation_and_parsing_admit_the_same_values() {
for sent in [
Value::from("de"),
Value::from("GER"),
Value::from("xyz"),
Value::from("zh_CN"),
Value::from("e"),
Value::from(419),
Value::Null,
] {
assert_eq!(
<Language as ScalarType>::is_valid(&sent),
door(sent.clone()).is_ok(),
"{sent}"
);
}
}
fn script_door(sent: Value) -> Result<ScriptSubtag, String> {
<ScriptSubtag as ScalarType>::parse(sent)
.map_err(|refused| refused.into_server_error(Pos::default()).message)
}
#[test]
fn the_script_door_folds_case_and_writes_back_titlecase() {
let canonical = Value::from("Latn");
for sent in ["Latn", "latn", "LATN", "lAtN"] {
let held =
script_door(Value::from(sent)).unwrap_or_else(|refused| panic!("`{sent}`: {refused}"));
assert_eq!(held.to_value(), canonical, "`{sent}`");
}
}
#[test]
fn the_script_door_folds_no_han_variant_onto_the_other() {
let simplified = script_door(Value::from("hans")).expect("a script");
let traditional = script_door(Value::from("HANT")).expect("a script");
assert_eq!(simplified.to_value(), Value::from("Hans"));
assert_eq!(traditional.to_value(), Value::from("Hant"));
assert_ne!(simplified, traditional);
}
#[test]
fn the_script_door_refuses_by_name() {
let short = script_door(Value::from("Lat")).expect_err("three letters is not a script");
assert!(short.contains("exactly four letters"), "{short}");
assert!(
script_door(Value::from(4)).is_err(),
"a number is not a script"
);
assert!(script_door(Value::Null).is_err());
for sent in [
Value::from("Latn"),
Value::from("lat"),
Value::from("Lat1"),
Value::from(4),
] {
assert_eq!(
<ScriptSubtag as ScalarType>::is_valid(&sent),
script_door(sent.clone()).is_ok(),
"{sent}"
);
}
}
fn region_door(sent: Value) -> Result<Region, String> {
<Region as ScalarType>::parse(sent)
.map_err(|refused| refused.into_server_error(Pos::default()).message)
}
#[test]
fn the_region_door_reads_both_grammars_from_strings() {
for (sent, canonical) in [
("DE", "DE"),
("de", "DE"),
("dE", "DE"),
("419", "419"),
("001", "001"),
("BU", "MM"),
("ZZ", "ZZ"),
] {
let held =
region_door(Value::from(sent)).unwrap_or_else(|refused| panic!("`{sent}`: {refused}"));
assert_eq!(held.to_value(), Value::from(canonical), "`{sent}`");
}
}
#[test]
fn a_numeric_region_operand_is_refused_so_that_leading_zeros_survive() {
assert!(
region_door(Value::from(419)).is_err(),
"even though `419` is a region"
);
assert!(region_door(Value::from(1)).is_err());
assert_eq!(
region_door(Value::from("001"))
.expect("a region")
.to_value(),
Value::from("001"),
"the zeros are part of the code"
);
assert!(
region_door(Value::from("1")).is_err(),
"and are not stripped or restored"
);
}
#[test]
fn a_region_refusal_names_the_arm_it_was_nearest() {
let letters = region_door(Value::from("DEU")).expect_err("three letters is not a region");
assert!(letters.contains("exactly two"), "{letters}");
let digits = region_door(Value::from("41")).expect_err("two digits is not a region");
assert!(digits.contains("exactly three"), "{digits}");
let mixed = region_door(Value::from("D1")).expect_err("neither grammar");
assert!(mixed.contains("never a mixture"), "{mixed}");
for sent in [
Value::from("DE"),
Value::from("419"),
Value::from("DEU"),
Value::from("D1"),
Value::from(419),
] {
assert_eq!(
<Region as ScalarType>::is_valid(&sent),
region_door(sent.clone()).is_ok(),
"{sent}"
);
}
}