use super::{ALIAS_PREFIX, DEPTH_CEILING, alias, aliases, refused};
fn minted(table: &str, depth: usize) -> String {
alias(ALIAS_PREFIX, table, depth)
}
#[test]
fn an_alias_wears_the_prefix_and_its_depth() {
assert_eq!(minted("scene", 0), "__ig_scene_0__");
assert_eq!(minted("scene", 7), "__ig_scene_7__");
assert_eq!(minted("scene", 12), "__ig_scene_12__");
assert!(minted("scene", 0).starts_with(ALIAS_PREFIX));
}
#[test]
fn the_table_is_distinct_at_every_depth() {
let minted = aliases(ALIAS_PREFIX, "scene", DEPTH_CEILING);
assert_eq!(minted.len(), DEPTH_CEILING);
for (depth, name) in minted.iter().enumerate() {
assert_eq!(name, &alias(ALIAS_PREFIX, "scene", depth));
}
let mut sorted = minted.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), DEPTH_CEILING, "{minted:?}");
}
#[test]
fn the_clamp_protects_the_prefix_the_depth_and_distinctness() {
let shared = "a_very_long_table_name_that_a_generator_would_plausibly_emit";
let first = minted(shared, 3);
let second = minted(&format!("{shared}_second"), 3);
assert!(first.len() <= 63, "{} bytes: {first}", first.len());
assert!(second.len() <= 63, "{} bytes: {second}", second.len());
assert!(first.starts_with(ALIAS_PREFIX));
assert!(first.ends_with("_3__"), "{first}");
assert!(second.ends_with("_3__"), "{second}");
assert_ne!(first, second);
}
#[test]
fn a_clamped_table_is_still_distinct_at_every_depth() {
let minted = aliases(
ALIAS_PREFIX,
"a_very_long_table_name_that_a_generator_would_plausibly_emit",
DEPTH_CEILING,
);
let mut sorted = minted.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), DEPTH_CEILING, "{minted:?}");
assert!(minted.iter().all(|name| name.len() <= 63), "{minted:?}");
}
#[test]
fn the_clamp_cuts_on_a_character_boundary() {
let minted = minted(&"é".repeat(60), 0);
assert!(minted.len() <= 63, "{} bytes: {minted}", minted.len());
assert!(minted.starts_with("__ig_é"), "{minted}");
}
#[test]
fn a_declared_prefix_moves_every_name() {
let minted = aliases("__mine", "scene", 3);
assert_eq!(
minted,
["__mine_scene_0__", "__mine_scene_1__", "__mine_scene_2__"]
);
}
#[test]
fn a_declared_depth_is_the_length() {
let deep = aliases(ALIAS_PREFIX, "scene", 16);
assert_eq!(deep.len(), 16);
assert_eq!(deep[15], "__ig_scene_15__");
assert_eq!(deep[DEPTH_CEILING], "__ig_scene_8__");
assert_eq!(aliases(ALIAS_PREFIX, "scene", 1), ["__ig_scene_0__"]);
}
#[test]
fn a_depth_of_zero_aliases_nothing() {
let why = refused(ALIAS_PREFIX, 0).expect("an alias array with no depths aliases nothing");
assert!(why.contains("aliases nothing"), "{why}");
assert!(refused(ALIAS_PREFIX, 1).is_none());
}
#[test]
fn a_prefix_leads_with_the_framework_fence() {
let why = refused("mine", DEPTH_CEILING).expect("a bare prefix confiscates a namespace");
assert!(why.contains("does not begin `__`"), "{why}");
assert!(refused("", DEPTH_CEILING).is_some(), "nor is an empty one");
assert!(refused("__mine", DEPTH_CEILING).is_none());
}
#[test]
fn a_prefix_is_letters_digits_and_underscores() {
let why = refused("__my-name", DEPTH_CEILING).expect("`-` is not in the alias charset");
assert!(why.contains('-'), "{why}");
assert!(refused("__my name", DEPTH_CEILING).is_some(), "nor a space");
assert!(refused("__mine2", DEPTH_CEILING).is_none());
}
#[test]
fn a_prefix_leaves_room_for_the_table_it_stands_for() {
let hungry = "__".to_owned() + &"x".repeat(52);
let why = refused(&hungry, DEPTH_CEILING).expect("nothing is left for the table");
assert!(why.contains("bytes for the table's own name"), "{why}");
let borderline = "__".to_owned() + &"x".repeat(46);
assert!(refused(&borderline, 10).is_none(), "{borderline}");
assert!(refused(&borderline, 11).is_some(), "{borderline}");
}
#[test]
fn a_declared_prefix_pays_for_itself_out_of_the_table() {
let prefix = "__legacy_schema_namespace";
assert!(refused(prefix, 12).is_none());
let minted = aliases(
prefix,
"a_table_name_long_enough_to_need_the_clamp_twice_over",
12,
);
assert!(minted.iter().all(|name| name.len() <= 63), "{minted:?}");
assert!(
minted.iter().all(|name| name.starts_with(prefix)),
"{minted:?}"
);
let mut sorted = minted.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), 12, "{minted:?}");
}