use super::{Face, UnionMember, UnionModel};
fn found() -> UnionModel {
UnionModel {
krate: syn::parse_quote!(::ingraph),
vis: syn::parse_quote!(pub),
name: ident("Found"),
members: vec![
member("Media", syn::parse_quote!(Media)),
member("Clip", syn::parse_quote!(Clip)),
member("Tape", syn::parse_quote!(Vec<u8>)),
],
error: None,
graphql: Vec::new(),
}
}
fn member(name: &str, ty: syn::Type) -> UnionMember {
UnionMember {
ident: ident(name),
ty,
}
}
fn ident(name: &str) -> syn::Ident {
syn::Ident::new(name, proc_macro2::Span::call_site())
}
fn emission(model: &UnionModel) -> syn::File {
syn::parse2(model.emit()).expect("the expansion parses")
}
fn rendered(model: &UnionModel) -> String {
prettyplease::unparse(&emission(model))
}
fn body(file: &syn::File) -> Vec<syn::Stmt> {
let block = file
.items
.iter()
.find_map(|item| match item {
syn::Item::Const(anonymous) if anonymous.ident == "_" => Some(&anonymous.expr),
_ => None,
})
.expect("the expansion holds one anonymous const");
let syn::Expr::Block(block) = block.as_ref() else {
panic!("the const's value is a block");
};
block.block.stmts.clone()
}
fn declared_structs(file: &syn::File) -> Vec<String> {
file
.items
.iter()
.filter_map(|item| match item {
syn::Item::Struct(item) => Some(item.ident.to_string()),
_ => None,
})
.collect()
}
fn methods(model: &UnionModel) -> Vec<String> {
face(&emission(model))
.iter()
.map(|method| method.sig.ident.to_string())
.collect()
}
fn const_methods(model: &UnionModel) -> Vec<String> {
face(&emission(model))
.iter()
.filter(|method| method.sig.constness.is_some())
.map(|method| method.sig.ident.to_string())
.collect()
}
fn face(file: &syn::File) -> Vec<syn::ImplItemFn> {
body(file)
.iter()
.filter_map(|stmt| match stmt {
syn::Stmt::Item(syn::Item::Impl(item)) if item.trait_.is_none() => Some(&item.items),
_ => None,
})
.flatten()
.filter_map(|item| match item {
syn::ImplItem::Fn(item) => Some(item.clone()),
_ => None,
})
.collect()
}
#[test]
fn the_expansion_declares_only_the_refusal_a_wrong_unwrap_answers_with() {
let file = emission(&found());
assert_eq!(declared_structs(&file), ["FoundUnwrapError"]);
assert_eq!(
file
.items
.iter()
.filter(|item| matches!(item, syn::Item::Const(_)))
.count(),
1
);
}
#[test]
fn every_member_gets_the_seven_methods_the_face_vocabulary_names() {
let model = found();
let expected: Vec<String> = model
.members
.iter()
.flat_map(|member| Face::ALL.map(|face| face.name(&member.word()).to_string()))
.collect();
assert_eq!(methods(&model), expected);
assert_eq!(
methods(&model)[..7],
[
"is_media",
"unwrap_media",
"unwrap_media_ref",
"unwrap_media_mut",
"try_unwrap_media",
"try_unwrap_media_ref",
"try_unwrap_media_mut"
]
);
}
#[test]
fn only_the_predicate_is_const() {
assert_eq!(
const_methods(&found()),
["is_media", "is_clip", "is_tape"],
"{}",
rendered(&found())
);
}
#[test]
fn the_refusal_carries_two_private_fields_and_reads_them_out() {
let file = emission(&found());
let refusal = file
.items
.iter()
.find_map(|item| match item {
syn::Item::Struct(item) => Some(item),
_ => None,
})
.expect("the expansion declares the refusal");
assert!(
refusal
.fields
.iter()
.all(|field| matches!(field.vis, syn::Visibility::Inherited)),
"{:?}",
refusal.fields
);
assert_eq!(
refusal
.fields
.iter()
.map(|field| field.ident.as_ref().expect("a named field").to_string())
.collect::<Vec<_>>(),
["asked", "held"]
);
let rendered = rendered(&found());
assert!(rendered.contains("pub const fn asked(&self)"), "{rendered}");
assert!(rendered.contains("pub const fn held(&self)"), "{rendered}");
}
#[test]
fn the_declared_name_is_what_the_whole_expansion_calls_the_refusal() {
let mut model = found();
model.error = Some(ident("NoSuchMember"));
assert_eq!(model.error(), "NoSuchMember");
assert_eq!(declared_structs(&emission(&model)), ["NoSuchMember"]);
let rendered = rendered(&model);
assert!(
rendered.contains("Result<Media, NoSuchMember>"),
"the signature a caller reads it out of: {rendered}"
);
assert!(
rendered.contains("NoSuchMember {"),
"and the construction: {rendered}"
);
assert!(!rendered.contains("FoundUnwrapError"), "{rendered}");
}
#[test]
fn a_renamed_refusal_still_names_the_union_in_its_sentence() {
const SENTENCE: &str = r#""`Found`: asked for `{}`, held `{}`""#;
assert!(rendered(&found()).contains(SENTENCE));
let mut model = found();
model.error = Some(ident("NoSuchMember"));
assert!(rendered(&model).contains(SENTENCE), "{}", rendered(&model));
}
#[test]
fn the_held_table_is_written_once_and_read_everywhere() {
let rendered = rendered(&found());
assert_eq!(
rendered.matches("fn __ingraph_held").count(),
1,
"{rendered}"
);
assert_eq!(
rendered.matches("= __ingraph_held(").count(),
3 * 3,
"{rendered}"
);
}
#[test]
fn a_one_member_union_has_no_wrong_variant_to_write_for() {
let mut model = found();
model.members.truncate(1);
let rendered = rendered(&model);
assert!(!rendered.contains("__ingraph_held"), "{rendered}");
assert!(
!rendered.contains("_ =>"),
"no fallback arm, so nothing builds a refusal there is no variant to earn: {rendered}"
);
assert_eq!(methods(&model).len(), 7);
assert_eq!(declared_structs(&emission(&model)), ["FoundUnwrapError"]);
assert!(
rendered.contains("Result<Media, FoundUnwrapError>"),
"{rendered}"
);
}
#[test]
fn the_expansion_is_core_and_nothing_else() {
let rendered = rendered(&found());
assert!(!rendered.contains("::ingraph"), "{rendered}");
assert!(!rendered.contains("__private"), "{rendered}");
assert!(!rendered.contains("async_graphql"), "{rendered}");
}
#[test]
fn every_emitted_item_is_exactly_as_visible_as_the_declaration() {
let mut model = found();
model.vis = syn::parse_quote!(pub(crate));
let rendered = rendered(&model);
assert!(
rendered.contains("pub(crate) struct FoundUnwrapError"),
"{rendered}"
);
assert!(
rendered.contains("pub(crate) const fn is_media"),
"{rendered}"
);
assert!(
rendered.contains("pub(crate) fn try_unwrap_media"),
"{rendered}"
);
assert!(!rendered.contains("pub struct"), "{rendered}");
}