use quote::quote;
use super::{ElementFamily, ElementModel};
fn tight(tokens: impl quote::ToTokens) -> String {
tokens.to_token_stream().to_string().replace(' ', "")
}
fn model(family: ElementFamily, subject: &str, inner: syn::Type) -> ElementModel {
let subject = syn::Ident::new(subject, proc_macro2::Span::call_site());
ElementModel {
vis: syn::parse_quote!(pub),
filter: crate::name::RustSafeName::from_ident(&crate::model::default_filter_name(&subject)),
krate: syn::parse_quote!(::ingraph),
family,
member: syn::Member::Unnamed(syn::Index {
index: 0,
span: proc_macro2::Span::call_site(),
}),
inner,
subject,
wire_name: None,
}
}
fn tag() -> ElementModel {
model(ElementFamily::String, "Tag", syn::parse_quote!(String))
}
#[test]
fn no_emitted_path_reaches_the_framework_without_the_shelf() {
let rendered = tight(tag().emit());
assert!(rendered.contains("::ingraph::__private::graphql::TextFilter"));
let unshelved = rendered.replace("::ingraph::__private::", "\u{1}");
for direct in [
"::ingraph::TextFilter",
"::ingraph::GraphqlFilter",
"::ingraph::ToGraphqlInput",
"::ingraph::ToGraphqlOutput",
"::ingraph::StringFilterMarker",
"::ingraph::DefaultMarker",
"::async_graphql::",
] {
assert!(
!unshelved.contains(direct),
"`{direct}` is spelled without the shelf:\n{rendered}"
);
}
}
#[test]
fn the_wire_half_is_behind_the_gate_and_the_filter_is_not() {
let rendered = tight(tag().emit());
let (before, after) = rendered
.split_once("if_async_graphql!")
.expect("the wire half rides the gate");
assert!(before.contains("pubstructTagFilter"), "{before}");
assert!(before.contains("StringFilterMarker"), "{before}");
assert!(before.contains("ToDatabaseComparison"), "{before}");
assert!(!before.contains("async_graphql::InputType"), "{before}");
assert!(after.contains("async_graphql::ScalarType"), "{after}");
assert!(after.contains("async_graphql::InputType"), "{after}");
assert!(after.contains("ToGraphqlInput"), "{after}");
assert!(after.contains("ToGraphqlOutput"), "{after}");
}
#[test]
fn the_minted_filter_takes_the_declarations_visibility() {
let mut private = tag();
private.vis = syn::Visibility::Inherited;
let rendered = tight(private.emit());
assert!(
rendered.contains("structTagFilter(pub(crate)"),
"{rendered}"
);
assert!(!rendered.contains("pubstructTagFilter"), "{rendered}");
}
#[test]
fn each_family_holds_the_frameworks_own_kind() {
for (family, kind) in [
(ElementFamily::Scalar, "ScalarFilter"),
(ElementFamily::String, "TextFilter"),
(ElementFamily::Bytes, "BytesFilter"),
(ElementFamily::Enum, "EnumFilter"),
] {
let rendered = tight(model(family, "Value", syn::parse_quote!(String)).emit());
assert!(
rendered.contains(&format!("__private::graphql::{kind}<Value>")),
"the {} family holds `{kind}`:\n{rendered}",
family.word()
);
}
}
#[test]
fn each_familys_operation_set_is_the_frameworks_own() {
for (family, count, present, absent) in [
(ElementFamily::Scalar, 8, "\"lte\"", "\"contains\""),
(ElementFamily::String, 20, "\"startsWithNocase\"", "\"any\""),
(
ElementFamily::Bytes,
10,
"\"notContains\"",
"\"startsWith\"",
),
(ElementFamily::Enum, 4, "\"notIn\"", "\"gt\""),
] {
let rendered = tight(model(family, "Value", syn::parse_quote!(String)).emit());
let slots = family.operations().len();
assert_eq!(
slots,
count,
"the {} family has {count} operators",
family.word()
);
assert!(rendered.contains(present), "{rendered}");
assert!(!rendered.contains(absent), "{rendered}");
}
}
#[test]
fn every_family_hands_out_what_it_holds_and_maps_what_it_carries() {
for (family, kind) in [
(ElementFamily::Scalar, "ScalarFilter"),
(ElementFamily::String, "TextFilter"),
(ElementFamily::Bytes, "BytesFilter"),
(ElementFamily::Enum, "EnumFilter"),
] {
let rendered = tight(model(family, "Value", syn::parse_quote!(String)).emit());
let held = format!("::ingraph::__private::graphql::{kind}<Value>");
assert!(
rendered.contains(&format!("pubfninto_inner(self)->{held}{{self.0}}")),
"the {} family hands the held filter out:\n{rendered}",
family.word(),
);
assert!(
rendered.contains(&format!("pubconstfnget(&self)->&{held}")),
"and keeps the borrowing one:\n{rendered}",
);
assert!(
rendered.contains("TryMapFilter<Value,__INGRAPH_STORED__>forValueFilter"),
"the {} family maps its operands:\n{rendered}",
family.word(),
);
assert!(
rendered.contains(&format!(
"typeMapped=<{held}as::ingraph::__private::graphql::TryMapFilter<Value,__INGRAPH_STORED__>>\
::Mapped;"
)),
"and projects `Mapped` off what it holds:\n{rendered}",
);
assert!(
rendered.contains("Self::into_inner(self)"),
"and delegates through the owning projection:\n{rendered}",
);
}
}
#[test]
fn the_enum_familys_door_mints_the_same_items_the_other_three_do() {
let model = model(ElementFamily::Enum, "Codec", syn::parse_quote!(String));
let rendered = tight(model.emit());
assert!(
rendered.contains(
"pubstructCodecFilter(pub(crate)::ingraph::__private::graphql::EnumFilter<Codec>);"
),
"{rendered}"
);
assert!(!rendered.contains("typeCodecFilter="), "{rendered}");
for present in [
"implCodecFilter", "GraphqlFilterforCodecFilter", "ToDatabaseComparison", "TryMapFilter<Codec,__INGRAPH_STORED__>forCodecFilter", "async_graphql::InputTypeforCodecFilter", "async_graphql::InputObjectTypeforCodecFilter", "NullableFaceforCodecFilter", ] {
assert!(
rendered.contains(present),
"a minting door emits `{present}`:\n{rendered}"
);
}
assert_eq!(model.family.operations().len(), 4);
for slot in ["\"eq\"", "\"ne\"", "\"in\"", "\"notIn\""] {
assert!(rendered.contains(slot), "{rendered}");
}
for present in [
"EnumFilterMarkerforCodec",
"DefaultMarkerforCodec",
"ScalarTypeforCodec",
"ToGraphqlInputforCodec",
"ToGraphqlOutputforCodec",
] {
assert!(rendered.contains(present), "{rendered}");
}
}
#[test]
fn the_enum_familys_mint_takes_the_declarations_visibility() {
let mut private = model(ElementFamily::Enum, "Codec", syn::parse_quote!(String));
private.vis = syn::Visibility::Inherited;
let rendered = tight(private.emit());
assert!(
rendered.contains("structCodecFilter(pub(crate)"),
"{rendered}"
);
assert!(!rendered.contains("pubstructCodecFilter"), "{rendered}");
}
#[test]
fn a_renamed_filter_moves_the_rust_name_and_the_wire_name_at_every_family() {
for family in ElementFamily::ALL {
let mut renamed = model(family, "Codec", syn::parse_quote!(String));
renamed.filter = crate::name::RustSafeName::from_ident(&syn::Ident::new(
"CodecPredicate",
proc_macro2::Span::call_site(),
));
let rendered = tight(renamed.emit());
let word = family.word();
assert!(
rendered.contains("pubstructCodecPredicate("),
"the {word} family mints the RENAMED type:\n{rendered}"
);
assert!(
rendered.contains(r#"Cow::Borrowed("CodecPredicate")"#),
"the {word} family publishes the RENAMED wire name:\n{rendered}"
);
assert!(
!rendered.contains("CodecFilter"),
"the {word} family leaves no `CodecFilter` behind:\n{rendered}"
);
}
}
#[test]
fn a_named_member_is_spelled_where_a_positional_one_is() {
let mut named = tag();
named.member = syn::Member::Named(syn::Ident::new("words", proc_macro2::Span::call_site()));
let rendered = tight(named.emit());
assert!(
rendered.contains("Self{words:__ingraph_inner}"),
"{rendered}"
);
assert!(rendered.contains("&self.words"), "{rendered}");
}
#[test]
fn the_two_wire_names_are_the_two_rust_names() {
let rendered = tight(tag().emit());
assert!(rendered.contains(r#"name="Tag""#), "{rendered}");
assert!(
rendered.contains(r#"Cow::Borrowed("TagFilter")"#),
"{rendered}"
);
}
#[test]
fn the_emission_is_a_well_formed_item_sequence() {
for family in ElementFamily::ALL {
let emitted = model(family, "Value", syn::parse_quote!(String)).emit();
syn::parse2::<syn::File>(quote!(#emitted))
.unwrap_or_else(|e| panic!("the {} family's emission parses: {e}", family.word()));
}
}