use ingraph_codegen::prelude::*;
use quote::ToTokens as _;
use crate::host;
fn record(input: &syn::DeriveInput) -> syn::Result<RecordModel> {
let (host, options) = host::split(input);
crate::parse::parse(&host, &options, NodeKind::Record)
}
fn artifacts(model: &RecordModel) -> Vec<(String, String)> {
model
.artifacts
.iter()
.map(|artifact| {
(
artifact.name.to_string(),
artifact
.family
.to_token_stream()
.to_string()
.replace(' ', ""),
)
})
.collect()
}
fn asks(model: &RecordModel) -> Vec<Option<String>> {
model
.artifacts
.iter()
.map(|artifact| {
artifact
.data
.as_ref()
.map(|data| data.name().unwrap_or_default().to_owned())
})
.collect()
}
fn refusals(input: &syn::DeriveInput) -> Vec<String> {
record(input)
.expect_err("this declaration is refused")
.into_iter()
.map(|error| error.to_string())
.collect()
}
fn names(messages: &[String], rule: &str) -> bool {
messages.iter().any(|message| message.contains(rule))
}
#[test]
fn the_full_form_reaches_the_model_as_a_family_and_an_ask() {
let model = record(&syn::parse_quote! {
#[ingraph(sqlite,
lineage(fields(media)),
graphql(async_graphql),
derived(tracks = "app::Track"),
locate(thumb(family = "app::Poster", data)),
)]
struct Frame { #[ingraph(id)] at: i64, media: String }
})
.expect("the ruling's own declaration");
assert_eq!(
artifacts(&model),
[("thumb".to_owned(), "app::Poster".to_owned())],
"the family is what `family = \"…\"` named"
);
assert_eq!(
asks(&model),
[Some(String::new())],
"the ask is present and names no field, which is the default"
);
assert_eq!(
model
.derived
.iter()
.map(|position| position.name.to_string())
.collect::<Vec<_>>(),
["tracks"],
"the reverse container beside it still reads its own entry"
);
assert!(
model.graphql.is_some(),
"and the wire face is still declared"
);
}
#[test]
fn a_named_ask_carries_its_wire_field_verbatim() {
let model = record(&syn::parse_quote! {
#[ingraph(sqlite,
lineage(fields(media)),
graphql(async_graphql),
locate(thumb(family = "app::Poster", data = "thumbBytes")),
)]
struct Frame { #[ingraph(id)] at: i64, media: String }
})
.expect("the rider's own spelling");
assert_eq!(asks(&model), [Some("thumbBytes".to_owned())]);
}
#[test]
fn a_full_form_that_asks_for_nothing_is_the_shorthand() {
let model = record(&syn::parse_quote! {
#[ingraph(sqlite,
lineage(fields(media)),
graphql(async_graphql),
locate(card = "app::Card", poster(family = "app::Poster")),
)]
struct Frame { #[ingraph(id)] at: i64, media: String }
})
.expect("both spellings in one block");
assert_eq!(
artifacts(&model),
[
("card".to_owned(), "app::Card".to_owned()),
("poster".to_owned(), "app::Poster".to_owned()),
],
"two forms, one block, one order"
);
assert_eq!(
asks(&model),
[None, None],
"and neither of them asked for bytes"
);
}
#[test]
fn the_ask_belongs_to_the_position_that_wrote_it() {
let model = record(&syn::parse_quote! {
#[ingraph(sqlite,
lineage(fields(media)),
graphql(async_graphql),
locate(
card = "app::Card",
poster(family = "app::Poster", data),
sheet(family = "app::Sheet", data = "sheetBytes"),
),
)]
struct Frame { #[ingraph(id)] at: i64, media: String }
})
.expect("three positions, three spellings");
assert_eq!(
asks(&model),
[None, Some(String::new()), Some("sheetBytes".to_owned())],
"the address alone, the default name, and the written one"
);
}
#[test]
fn refuses_a_full_form_that_names_no_family() {
for written in [
quote::quote!(locate(card())),
quote::quote!(locate(card(data))),
quote::quote!(locate(card(data = "cardBytes"))),
] {
let refused = refusals(&syn::parse_quote! {
#[ingraph(#written)]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"an artifact position's full form names the family it addresses"
) && names(&refused, "`family = \"path::to::Family\"`"),
"{written}: {refused:?}"
);
}
}
#[test]
fn refuses_a_family_that_is_not_a_type_path() {
for written in [
quote::quote!(locate(card(family = Card, data))),
quote::quote!(locate(card(family = "not a path", data))),
quote::quote!(locate(card(family, data))),
] {
let refused = refusals(&syn::parse_quote! {
#[ingraph(#written)]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"`family` names the `#[ingraph::blob]` node this position addresses"
),
"{written}: {refused:?}"
);
}
}
#[test]
fn refuses_an_ask_that_carries_anything_but_a_name() {
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(card(family = "app::Card", data = 4096)))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"the `data` ask is written bare, `data = \"thumbBytes\"` to name the wire field"
) && names(&refused, "The default name is `<name>Data`"),
"{refused:?}"
);
}
#[test]
fn the_ask_block_takes_a_rename_and_the_required_word() {
let model = record(&syn::parse_quote! {
#[ingraph(sqlite, locate(card(family = "app::Card", data(rename = "cardBytes", required))))]
struct Frame { #[ingraph(id)] at: i64 }
})
.expect("the block form is legal");
let bytes = model.artifacts[0]
.data
.as_ref()
.expect("the position asked");
assert_eq!(bytes.name(), Some("cardBytes"));
assert!(bytes.required());
let model = record(&syn::parse_quote! {
#[ingraph(sqlite, locate(card(family = "app::Card", data)))]
struct Frame { #[ingraph(id)] at: i64 }
})
.expect("the bare ask is legal");
let bytes = model.artifacts[0]
.data
.as_ref()
.expect("the position asked");
assert_eq!(bytes.name(), None);
assert!(!bytes.required());
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(card(family = "app::Card", data(nullable))))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(&refused, "There is no word for the nullable form"),
"the one-way law is in the sentence: {refused:?}"
);
}
#[test]
fn refuses_a_repeated_ask() {
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(card(family = "app::Card", data, data = "cardBytes")))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"`data` is declared more than once in an artifact position"
),
"{refused:?}"
);
}
#[test]
fn refuses_a_repeated_family() {
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(card(family = "app::Card", family = "app::Poster")))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"`family` is declared more than once in an artifact position"
),
"{refused:?}"
);
}
#[test]
fn refuses_two_asks_naming_one_wire_field() {
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(
card(family = "app::Card", data = "bytes"),
poster(family = "app::Poster", data = "bytes"),
))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(
&refused,
"`bytes` is the wire field `card` already asks for"
) && names(&refused, "One namespace per face"),
"{refused:?}"
);
}
#[test]
fn refuses_an_unknown_option_and_suggests_the_near_miss() {
let refused = refusals(&syn::parse_quote! {
#[ingraph(locate(card(famly = "app::Card", data)))]
struct Frame { #[ingraph(id)] at: i64 }
});
assert!(
names(&refused, "unknown entry in an artifact position")
&& names(&refused, "did you mean `family`"),
"{refused:?}"
);
}