use ingraph_codegen::{model::GraphqlKind, newtype::Gate};
fn declared(
block: proc_macro2::TokenStream,
) -> syn::Result<ingraph_codegen::newtype::NewTypeModel> {
super::parse(&syn::parse_quote! {
#[ingraph(#block)]
pub struct Tag(String);
})
}
fn refusals(block: proc_macro2::TokenStream) -> String {
let Err(refused) = declared(block) else {
panic!("the block is refused")
};
refused
.into_iter()
.map(|error| error.to_string())
.collect::<Vec<_>>()
.join(" | ")
}
#[test]
fn a_wire_word_written_one_level_up_is_an_unknown_backend() {
let refused = refusals(quote::quote!(graphql(scalar)));
assert!(
refused.contains("unknown backend in `graphql(…)`"),
"{refused}"
);
assert!(refused.contains("one level down"), "{refused}");
assert!(
refused.contains("graphql(async_graphql(scalar))"),
"the refusal spells the nested form: {refused}"
);
}
#[test]
fn a_backend_this_framework_does_not_ship_is_refused() {
let refused = refusals(quote::quote!(graphql(juniper(scalar))));
assert!(
refused.contains("unknown backend in `graphql(…)`"),
"{refused}"
);
}
#[test]
fn the_domain_block_and_its_cells_are_each_declared_once() {
let domain = refusals(quote::quote!(
graphql(async_graphql(scalar)),
graphql(async_graphql(input))
));
assert!(
domain.contains("`graphql(…)` is declared more than once"),
"{domain}"
);
let backend = refusals(quote::quote!(graphql(
async_graphql(scalar),
async_graphql(input)
)));
assert!(
backend.contains("is declared more than once in `graphql(…)`"),
"{backend}"
);
let face = refusals(quote::quote!(graphql(async_graphql(input, input))));
assert!(
face.contains("`input` is declared more than once in this backend's block"),
"{face}"
);
}
#[test]
fn an_empty_block_at_either_depth_is_refused() {
let no_backend = refusals(quote::quote!(graphql));
assert!(no_backend.contains("names no backend"), "{no_backend}");
assert!(
no_backend.contains(&format!(
"graphql({first}(scalar))",
first = GraphqlKind::ALL[0].as_str()
)),
"{no_backend}"
);
let no_face = refusals(quote::quote!(graphql(async_graphql)));
assert!(
no_face.contains("dresses this newtype for no face"),
"{no_face}"
);
}
#[test]
fn the_backend_block_takes_the_three_faces() {
let model = declared(quote::quote!(graphql(async_graphql(scalar, input, output))))
.expect("the three faces");
assert!(model.kits.scalar.is_some());
assert!(model.kits.input);
assert!(model.kits.output);
let refused = refusals(quote::quote!(graphql(async_graphql(operand))));
assert!(
refused.contains("unknown entry in a newtype's `async_graphql` block"),
"{refused}"
);
}
#[test]
fn the_nullable_word_refuses_by_name_and_says_where_the_face_already_comes_from() {
let refused = refusals(quote::quote!(graphql(async_graphql(nullable))));
assert!(
refused.contains("`nullable` is a word this roster carries"),
"{refused}"
);
assert!(refused.contains("FILTER KINDS"), "{refused}");
assert!(
!refused.contains("did you mean"),
"a word the sentence refuses by name earns no near miss: {refused}"
);
}
#[test]
fn the_scalar_cell_carries_the_schema_name_and_the_door() {
let model = declared(quote::quote!(graphql(async_graphql(scalar(
rename = "Subtag",
parse = "door"
)))))
.expect("a renamed scalar with a text door");
let scalar = model.kits.scalar.as_ref().expect("the kit");
assert_eq!(scalar.rename.as_deref(), Some("Subtag"));
assert!(matches!(scalar.gate, Some(Gate::Parse(_))));
let bare = declared(quote::quote!(graphql(async_graphql(scalar)))).expect("a bare scalar");
let kit = bare.kits.scalar.as_ref().expect("the kit");
assert!(kit.rename.is_none());
assert!(kit.gate.is_none());
}
#[test]
fn a_schema_name_outside_graphqls_grammar_is_refused() {
let refused = refusals(quote::quote!(graphql(async_graphql(scalar(
rename = "Sub Tag"
)))));
assert!(refused.contains("Sub Tag"), "{refused}");
}
#[test]
fn the_two_crossings_take_no_options() {
let refused = refusals(quote::quote!(graphql(async_graphql(output(rename = "X")))));
assert!(refused.contains("`output` takes no options"), "{refused}");
}