use super::{Face, Mode};
fn refused(read: syn::Result<Mode>) -> String {
match read {
Ok(_) => panic!("the declaration is refused"),
Err(errors) => errors
.into_iter()
.map(|error| error.to_string())
.collect::<Vec<_>>()
.join("\n"),
}
}
fn composed(read: syn::Result<Mode>) -> ingraph_codegen::composed::ComposedModel {
match read.expect("a `composed` declaration reads as a composed filter") {
Mode::Composed(model) => *model,
Mode::Element(_) | Mode::Struct(_) => panic!("`composed` is this mode's watershed"),
}
}
fn slots(model: &ingraph_codegen::composed::ComposedModel) -> Vec<&str> {
model
.fields
.iter()
.filter_map(|field| match &field.kind {
ingraph_codegen::composed::ComposedKind::Slot(wire) => Some(wire.as_str()),
ingraph_codegen::composed::ComposedKind::Spliced => None,
})
.collect::<Vec<_>>()
}
fn spliced(model: &ingraph_codegen::composed::ComposedModel) -> Vec<String> {
model
.fields
.iter()
.filter(|field| matches!(field.kind, ingraph_codegen::composed::ComposedKind::Spliced))
.map(|field| field.member.to_string())
.collect::<Vec<_>>()
}
#[test]
fn the_marker_decides_the_identity() {
let unmarked: syn::DeriveInput = syn::parse_quote! {
pub struct Where {
eq: Option<i64>,
}
};
assert!(matches!(
super::parse(&unmarked, Face::Filter).expect("an unmarked struct is the struct mode"),
Mode::Struct(_)
));
let marked: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
eq: Option<i64>,
}
};
assert_eq!(
slots(&composed(super::parse(&marked, Face::Filter))),
["eq"]
);
}
#[test]
fn the_slot_table_is_the_fields_in_order() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct RateFilter {
eq: Option<Rate>,
in_: Option<Box<[Rate]>>,
not_in: Option<Box<[Rate]>>,
starts_with: Option<Utf8Bytes>,
numerator: Option<ScalarFilter<i32>>,
}
};
let model = composed(super::parse(&input, Face::Filter));
assert_eq!(
slots(&model),
["eq", "in", "notIn", "startsWith", "numerator"]
);
assert_eq!(model.sdl.external(), "RateFilter");
}
#[test]
fn a_raw_slot_name_folds_to_the_word_it_escapes() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
r#in: Option<Box<[i64]>>,
}
};
assert_eq!(slots(&composed(super::parse(&input, Face::Filter))), ["in"]);
}
#[test]
fn the_rename_words_move_the_object_and_the_slot() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed, filter(rename = "ClipWhere"))]
pub struct ClipCriteria {
#[ingraph(rename = "atLeast")]
gte: Option<Rate>,
}
};
let model = composed(super::parse(&input, Face::Filter));
assert_eq!(model.sdl.external(), "ClipWhere");
assert_eq!(slots(&model), ["atLeast"]);
}
#[test]
fn a_slot_may_be_renamed_onto_a_rust_keyword() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(rename = "in")]
members: Option<Box<[i64]>>,
}
};
assert_eq!(slots(&composed(super::parse(&input, Face::Filter))), ["in"]);
}
#[test]
fn a_slot_that_is_not_optional_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
eq: i64,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(refusal.contains("`eq` is an operator SLOT"), "{refusal}");
assert!(refusal.contains("Option<i64>"), "{refusal}");
}
#[test]
fn the_two_markers_refuse_together() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed, operator(string))]
pub struct Tag(String);
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`operator(…)` and `composed` are the two ELEMENT and FILTER readings"),
"{refusal}"
);
}
#[test]
fn an_empty_declaration_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("a COMPOSED filter's fields ARE its vocabulary"),
"{refusal}"
);
}
#[test]
fn two_fields_folding_onto_one_slot_are_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
not_in: Option<Box<[i64]>>,
#[ingraph(rename = "notIn")]
excluded: Option<Box<[i64]>>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`excluded` and `not_in` are both the slot `notIn`"),
"{refusal}"
);
}
#[test]
fn a_slot_renamed_outside_the_name_grammar_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(rename = "not-in")]
not_in: Option<Box<[i64]>>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`not-in` is not a GraphQL name"),
"{refusal}"
);
}
#[test]
fn a_column_word_on_a_slot_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(scalar)]
eq: Option<i64>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("a COMPOSED filter's field takes `rename = \"…\"` and `flatten`"),
"{refusal}"
);
}
#[test]
fn the_marker_is_the_filter_doors_word() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
eq: Option<i64>,
}
};
for face in [Face::Comparison, Face::OrderBy] {
let refusal = refused(super::parse(&input, face));
assert!(
refusal.contains("`composed` declares a FILTER and reaches no face"),
"{refusal}"
);
}
}
#[test]
fn the_words_a_composed_filter_does_not_spend_refuse_by_name() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(
composed,
sqlite,
comparison(rename = "WhereRow"),
order_by(rename = "WhereSort"),
filter = "crate::Seat"
)]
pub struct Where {
eq: Option<i64>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
for word in [
"`order_by(rename = \"…\")` reaches no face the COMPOSED mode emits",
"`comparison(rename = \"…\")` reaches no face the COMPOSED mode emits",
"`filter = \"…\"` reaches no face the COMPOSED mode emits",
"`sqlite` reaches no face the COMPOSED mode emits",
] {
assert!(refusal.contains(word), "{word}\n{refusal}");
}
}
#[test]
fn the_marker_takes_no_value() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed = "Where")]
pub struct Where {
eq: Option<i64>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`composed` is a MARKER and takes no value"),
"{refusal}"
);
}
#[test]
fn the_marker_block_takes_one_word() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed(eq))]
pub struct Where {
eq: Option<i64>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`composed(…)` takes `shorthand = <bool>` and nothing else"),
"{refusal}"
);
}
#[test]
fn the_shorthand_is_taken_by_silence_and_declined_by_word() {
let bare: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
eq: Option<i64>,
}
};
assert!(composed(super::parse(&bare, Face::Filter)).shorthand);
let empty: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed())]
pub struct Where {
eq: Option<i64>,
}
};
assert!(composed(super::parse(&empty, Face::Filter)).shorthand);
let taken: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed(shorthand = true))]
pub struct Where {
eq: Option<i64>,
}
};
assert!(composed(super::parse(&taken, Face::Filter)).shorthand);
let declined: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed(shorthand = false))]
pub struct Where {
contains: Option<i64>,
}
};
assert!(!composed(super::parse(&declined, Face::Filter)).shorthand);
}
#[test]
fn the_shorthand_flag_is_a_boolean() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed(shorthand = "no"))]
pub struct Where {
eq: Option<i64>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`composed(shorthand = …)` must be `true` or `false`"),
"{refusal}"
);
}
#[test]
fn a_flattened_field_is_spliced_rather_than_named() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct SoundEventDetectionFilter {
#[ingraph(flatten)]
code: CodeFilter,
under: Option<Box<[SoundEventCode]>>,
score: Option<ScalarFilter<Score>>,
}
};
let model = composed(super::parse(&input, Face::Filter));
assert_eq!(slots(&model), ["under", "score"]);
assert_eq!(spliced(&model), ["code"]);
}
#[test]
fn a_renamed_splice_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(flatten, rename = "code")]
code: CodeFilter,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`code` is SPLICED, so it has no name of its own for `rename` to move"),
"{refusal}"
);
}
#[test]
fn an_optional_splice_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(flatten)]
code: Option<CodeFilter>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(
refusal.contains("`code` is SPLICED and a spliced component is written BARE"),
"{refusal}"
);
}
#[test]
fn a_flatten_with_a_block_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where {
#[ingraph(flatten(prefix = "code"))]
code: CodeFilter,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(refusal.contains("`flatten` is written BARE"), "{refusal}");
}
#[test]
fn a_generic_declaration_is_refused() {
let input: syn::DeriveInput = syn::parse_quote! {
#[ingraph(composed)]
pub struct Where<T> {
eq: Option<T>,
}
};
let refusal = refused(super::parse(&input, Face::Filter));
assert!(refusal.contains("takes a CONCRETE struct"), "{refusal}");
}