use ingraph_codegen::union::UnionModel;
use quote::ToTokens as _;
fn parse(input: &syn::DeriveInput) -> syn::Result<UnionModel> {
super::parse(input)
}
fn members(model: &UnionModel) -> Vec<(String, String)> {
model
.members
.iter()
.map(|member| {
(
member.ident.to_string(),
member.ty.to_token_stream().to_string().replace(' ', ""),
)
})
.collect()
}
fn refusal(input: &syn::DeriveInput) -> String {
parse(input)
.expect_err("the declaration is refused")
.into_iter()
.map(|error| error.to_string())
.collect::<Vec<_>>()
.join(" | ")
}
#[test]
fn a_bare_union_is_the_types_its_variants_carry() {
let model = parse(&syn::parse_quote! {
pub enum Found {
Media(Media),
Clip(Clip),
}
})
.expect("one member per variant is the whole shape");
assert_eq!(model.name, "Found");
assert_eq!(
members(&model),
[
("Media".to_owned(), "Media".to_owned()),
("Clip".to_owned(), "Clip".to_owned()),
]
);
assert_eq!(model.error, None);
assert_eq!(model.error(), "FoundUnwrapError");
}
#[test]
fn a_member_is_any_type_the_declaration_carries() {
let model = parse(&syn::parse_quote! {
enum Held {
Media(crate::media::Media),
Bytes(Vec<u8>),
Pair((u8, u16)),
Count(u32),
}
})
.expect("a member type is not this derive's business");
assert_eq!(
members(&model)
.into_iter()
.map(|(_, ty)| ty)
.collect::<Vec<_>>(),
["crate::media::Media", "Vec<u8>", "(u8,u16)", "u32"]
);
}
#[test]
fn one_member_is_a_union() {
let model = parse(&syn::parse_quote! {
enum Only { Media(Media) }
})
.expect("one or more");
assert_eq!(members(&model).len(), 1);
}
#[test]
fn the_refusal_type_is_named_by_the_declaration_or_by_the_convention() {
let named = parse(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = "NoSuchSide"))]
enum Side { Left(Media), Right(Clip) }
})
.expect("a union may name the one type it emits");
assert_eq!(named.error, Some(syn::parse_quote!(NoSuchSide)));
assert_eq!(named.error(), "NoSuchSide");
let defaulted = parse(&syn::parse_quote! {
enum Side { Left(Media), Right(Clip) }
})
.expect("and a declaration that says nothing keeps the convention");
assert_eq!(defaulted.error, None);
assert_eq!(defaulted.error(), "SideUnwrapError");
}
#[test]
fn a_refusal_may_be_named_with_a_raw_identifier() {
let model = parse(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = "r#type"))]
enum Side { Left(Media), Right(Clip) }
})
.expect("`r#type` is an identifier");
assert_eq!(model.error(), "r#type");
}
#[test]
fn refuses_a_refusal_named_after_the_union() {
let refused = refusal(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = "Side"))]
enum Side { Left(Media), Right(Clip) }
});
assert!(
refused.contains("already the union's own name"),
"{refused}"
);
}
#[test]
fn refuses_a_refusal_name_that_is_not_an_identifier() {
for spelling in ["", "Not An Ident", "9Lives"] {
let refused = refusal(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = #spelling))]
enum Side { Left(Media), Right(Clip) }
});
assert!(
refused.contains("must be a valid identifier"),
"{spelling:?}: {refused}"
);
}
}
#[test]
fn refuses_an_error_block_that_names_nothing() {
for input in [
syn::parse_quote! {
#[ingraph(unwrap_error)]
enum Side { Left(Media) }
},
syn::parse_quote! {
#[ingraph(unwrap_error())]
enum Side { Left(Media) }
},
] {
let refused = refusal(&input);
assert!(
refused.contains("`unwrap_error(…)` needs `rename = \"…\"`"),
"{refused}"
);
}
let twice = refusal(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = "A", rename = "B"))]
enum Side { Left(Media) }
});
assert!(
twice.contains("declared more than once in `unwrap_error(…)`"),
"{twice}"
);
}
#[test]
fn refuses_a_declaration_that_is_not_an_enum() {
let refused = refusal(&syn::parse_quote! {
struct Found { media: Media }
});
assert!(refused.contains("supports enums only"), "{refused}");
}
#[test]
fn refuses_an_enum_with_no_variants() {
let refused = refusal(&syn::parse_quote! {
enum Found {}
});
assert!(refused.contains("declares no union"), "{refused}");
assert!(refused.contains("ONE OR MORE unique member"), "{refused}");
}
#[test]
fn refuses_every_variant_that_carries_no_member() {
let refused = refusal(&syn::parse_quote! {
enum Found { Media(Media), Bare, Empty() }
});
assert!(refused.contains("`Bare` carries none"), "{refused}");
assert!(refused.contains("`Empty` carries none"), "{refused}");
}
#[test]
fn refuses_a_variant_carrying_more_than_one_member() {
let refused = refusal(&syn::parse_quote! {
enum Found { Media(Media), Both(Media, Clip) }
});
assert!(refused.contains("`Both` carries 2"), "{refused}");
assert!(refused.contains("single-value tuple variant"), "{refused}");
}
#[test]
fn refuses_a_member_carried_in_a_named_field() {
let refused = refusal(&syn::parse_quote! {
enum Found { Media(Media), Clip { clip: Clip } }
});
assert!(refused.contains("`Clip` names its payload"), "{refused}");
}
#[test]
fn refuses_a_generic_union() {
let refused = refusal(&syn::parse_quote! {
enum Pick<A, B> { Left(A), Right(B) }
});
assert!(refused.contains("generic unions"), "{refused}");
assert!(
refused.contains("`Pick<A, B>` is one member twice"),
"{refused}"
);
}
#[test]
fn refuses_a_lifetime_and_a_where_clause_for_the_same_reason() {
let by_lifetime = refusal(&syn::parse_quote! {
enum Found<'a> { Media(&'a Media) }
});
assert!(by_lifetime.contains("generic unions"), "{by_lifetime}");
let by_clause = refusal(&syn::parse_quote! {
enum Found where Self: Sized { Media(Media) }
});
assert!(by_clause.contains("generic unions"), "{by_clause}");
}
#[test]
fn refuses_two_variants_that_carry_one_member_type() {
let refused = refusal(&syn::parse_quote! {
enum Found { Media(Media), Cover(Media) }
});
assert!(
refused.contains("`Cover` and `Media` carry ONE member type"),
"{refused}"
);
assert!(refused.contains("UNIQUE member types"), "{refused}");
}
#[test]
fn one_type_reached_through_two_paths_is_past_what_tokens_can_see() {
parse(&syn::parse_quote! {
enum Found { Media(Media), Same(media::Media) }
})
.expect("two token streams, and only a type checker knows they are one type");
}
#[test]
fn refuses_two_variants_that_derive_one_word() {
let refused = refusal(&syn::parse_quote! {
enum Found { Vp9(Media), VP9(Clip) }
});
assert!(refused.contains("both derive `is_vp9`"), "{refused}");
}
#[test]
fn refuses_an_entry_a_union_does_not_take() {
let on_the_enum = refusal(&syn::parse_quote! {
#[ingraph(persist(sqlite))]
enum Found { Media(Media) }
});
assert!(on_the_enum.contains("unknown entry"), "{on_the_enum}");
assert!(
on_the_enum.contains("`unwrap_error(rename = \"…\")`, `graphql(…)` and `crate = \"…\"`"),
"{on_the_enum}"
);
let on_a_variant = refusal(&syn::parse_quote! {
enum Found {
#[ingraph(rename = "media")]
Media(Media),
}
});
assert!(
on_a_variant.contains("on a union's variant — a variant takes none"),
"{on_a_variant}"
);
}
#[test]
fn one_pass_reports_the_grammar_and_the_shape_together() {
let refused = refusal(&syn::parse_quote! {
#[ingraph(persist(sqlite))]
enum Found { Bare }
});
assert!(refused.contains("unknown entry"), "{refused}");
assert!(refused.contains("`Bare` carries none"), "{refused}");
}
#[test]
fn the_crate_the_expansion_is_rooted_at_is_the_declarations_to_move() {
let moved = parse(&syn::parse_quote! {
#[ingraph(crate = "shim::ingraph")]
enum Found { Media(Media) }
})
.expect("the wire round bought this option");
assert_eq!(moved.krate, syn::parse_quote!(shim::ingraph));
let defaulted = parse(&syn::parse_quote! {
enum Found { Media(Media) }
})
.expect("and a declaration that says nothing keeps the convention");
assert_eq!(defaulted.krate, syn::parse_quote!(::ingraph));
let twice = refusal(&syn::parse_quote! {
#[ingraph(crate = "a::b", crate = "c::d")]
enum Found { Media(Media) }
});
assert!(
twice.contains("`crate` is declared more than once"),
"{twice}"
);
}
#[test]
fn a_raw_variant_keeps_its_spelling_and_loses_its_escape() {
let model = parse(&syn::parse_quote! {
enum Found { r#type(Media) }
})
.expect("a raw identifier is a variant like any other");
let member = &model.members[0];
assert_eq!(member.ident.to_string(), "r#type");
assert_eq!(member.name(), "type");
assert_eq!(member.word(), "type");
}
#[test]
fn refuses_the_old_spelling_of_the_refusals_knob_by_naming_the_new_one() {
let moved = refusal(&syn::parse_quote! {
#[ingraph(error(rename = "NoSuchSide"))]
enum Side { Left(Media), Right(Clip) }
});
assert!(
moved.contains("`error` names CONVERSION CELLS now"),
"{moved}"
);
assert!(moved.contains("`unwrap_error(rename = \"…\")`"), "{moved}");
}
#[test]
fn the_options_are_read_off_the_item_the_derive_sits_on() {
let model = parse(&syn::parse_quote! {
#[ingraph(unwrap_error(rename = "Nope"))]
enum SearchResult { Media(Media) }
})
.expect("a derive's options are the block beside the declaration");
assert_eq!(model.error(), "Nope");
}