use ingraph_codegen::error::{BindingAt, ErrorRoad, RESERVED, VariantShape};
use super::parse;
fn read(
input: &syn::DeriveInput,
road: ErrorRoad,
) -> syn::Result<ingraph_codegen::error::ErrorModel> {
let (host, arguments) = crate::host::split(input);
parse(&host, &arguments, road)
}
fn refused(input: &syn::DeriveInput) -> String {
read(input, ErrorRoad::Mutation)
.err()
.map(|error| {
error
.into_iter()
.map(|one| one.to_string())
.collect::<Vec<_>>()
.join("\n")
})
.unwrap_or_else(|| panic!("the declaration was accepted"))
}
fn accepted(input: &syn::DeriveInput) -> ingraph_codegen::error::ErrorModel {
read(input, ErrorRoad::Mutation).expect("the declaration is accepted")
}
#[test]
fn the_two_words_are_read_off_every_variant() {
let model = accepted(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOT_A_DIRECTORY", error = "`{0}` is not a directory")]
NotADirectory(PathBuf),
#[ingraph(code = "SHUTTING_DOWN", error = "winding down")]
ShuttingDown,
}
});
assert_eq!(model.name, "WatchError");
assert_eq!(model.variants.len(), 2);
assert_eq!(model.variants[0].code.value(), "NOT_A_DIRECTORY");
assert_eq!(model.variants[0].shape, VariantShape::Tuple);
assert_eq!(model.variants[1].shape, VariantShape::Unit);
}
#[test]
fn the_code_heads_the_template_and_the_placeholder_is_rewritten() {
let model = accepted(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOT_A_DIRECTORY", error = "`{0}` is not a directory")]
NotADirectory(PathBuf),
}
});
assert_eq!(
model.variants[0].rendering.template,
"NOT_A_DIRECTORY: `{__ingraph_at_0}` is not a directory"
);
assert_eq!(model.variants[0].rendering.bound.len(), 1);
assert_eq!(
model.variants[0].rendering.bound[0].at,
BindingAt::Position(0)
);
}
#[test]
fn every_placeholder_shape_resolves_to_a_binding() {
let model = accepted(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "TUPLE", error = "{} then {1} then {0:>4}")]
Tuple(u8, u8),
#[ingraph(code = "NAMED", error = "{root} at {depth:?}")]
Named { root: String, depth: u8 },
#[ingraph(code = "BRACES", error = "a literal {{ and a }}")]
Braces,
}
});
assert_eq!(
model.variants[0].rendering.template,
"TUPLE: {__ingraph_at_0} then {__ingraph_at_1} then {__ingraph_at_0:>4}"
);
assert_eq!(model.variants[0].rendering.bound.len(), 2);
assert_eq!(
model.variants[1].rendering.template,
"NAMED: {__ingraph_named_root} at {__ingraph_named_depth:?}"
);
assert_eq!(
model.variants[1].rendering.bound[0].at,
BindingAt::Named(syn::parse_quote!(root))
);
assert_eq!(
model.variants[2].rendering.template,
"BRACES: a literal {{ and a }}"
);
assert!(model.variants[2].rendering.bound.is_empty());
}
#[test]
fn a_field_read_twice_is_bound_once() {
let model = accepted(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "TWICE", error = "{root} and again {root}")]
Twice { root: String },
}
});
assert_eq!(model.variants[0].rendering.bound.len(), 1);
}
#[test]
fn an_error_with_no_variants_is_accepted() {
let model = accepted(&syn::parse_quote! {
pub enum Never {}
});
assert!(model.variants.is_empty());
}
#[test]
fn both_roads_read_the_same_declaration() {
let written: syn::DeriveInput = syn::parse_quote! {
pub enum LookupError {
#[ingraph(code = "NO_SUCH_SHELF", error = "no shelf called `{0}`")]
NoSuchShelf(String),
}
};
assert_eq!(
read(&written, ErrorRoad::Mutation).expect("accepted").road,
ErrorRoad::Mutation
);
assert_eq!(
read(&written, ErrorRoad::Query).expect("accepted").road,
ErrorRoad::Query
);
}
#[test]
fn a_variant_with_no_code_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(error = "nothing names this")]
Unnamed,
}
});
assert!(
refusal.contains("`Unnamed` declares no `code`"),
"{refusal}"
);
}
#[test]
fn a_code_that_is_not_screaming_is_refused() {
for word in [
"notScreaming",
"lower_case",
"_LEADING",
"TRAILING_",
"",
"9LIVES",
] {
let written: syn::DeriveInput = syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = #word, error = "a sentence")]
Arm,
}
};
let refusal = refused(&written);
assert!(
refusal.contains("is not `SCREAMING_SNAKE_CASE`"),
"`{word}`: {refusal}"
);
}
}
#[test]
fn a_code_may_carry_digits() {
let model = accepted(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "HTTP_404", error = "gone")]
Gone,
}
});
assert_eq!(model.variants[0].code.value(), "HTTP_404");
}
#[test]
fn two_variants_under_one_code_are_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "SAME", error = "one")]
First,
#[ingraph(code = "SAME", error = "two")]
Second,
}
});
assert!(
refusal.contains("`SAME` is already the code of `First`"),
"{refusal}"
);
}
#[test]
fn a_framework_code_is_refused() {
for word in RESERVED {
let written: syn::DeriveInput = syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = #word, error = "a sentence")]
Arm,
}
};
let refusal = refused(&written);
assert!(
refusal.contains("is one of the framework's own wire codes and is reserved"),
"`{word}`: {refusal}"
);
}
}
#[test]
fn every_reserved_word_is_one_the_framework_publishes() {
let published: Vec<&str> = [
ingraph::ErrorCode::RepeatedOrderSubject,
ingraph::ErrorCode::AmbiguousPageDirection,
ingraph::ErrorCode::UnusableCursor,
ingraph::ErrorCode::StoreRefused,
ingraph::ErrorCode::UnsupportedFilter,
ingraph::ErrorCode::UnrenderableOrder,
ingraph::ErrorCode::UnpageableOrder,
ingraph::ErrorCode::UnreadableRow,
ingraph::ErrorCode::OversizedSkip,
ingraph::ErrorCode::UnwrittenArtifact,
ingraph::ErrorCode::UnusableAddress,
ingraph::ErrorCode::UnreachableSource,
ingraph::ErrorCode::UnreachableNode,
ingraph::ErrorCode::RequestDropped,
ingraph::ErrorCode::RequestTimedOut,
]
.iter()
.map(|code| code.as_str())
.collect();
for word in RESERVED {
assert!(
published.contains(word),
"`{word}` is reserved and this framework publishes no such code"
);
}
}
#[test]
fn a_variant_with_no_error_word_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "SILENT")]
Silent,
}
});
assert!(
refusal.contains("`Silent` declares no `error`"),
"{refusal}"
);
}
#[test]
fn a_placeholder_naming_no_field_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "{missing} is not here")]
Arm { root: String },
}
});
assert!(
refusal.contains("`Arm` has no field called `missing`"),
"{refusal}"
);
}
#[test]
fn a_position_past_the_last_field_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "{3} is not here")]
Arm(u8),
}
});
assert!(
refusal.contains("names field 3 of `Arm`, which has 1"),
"{refusal}"
);
}
#[test]
fn a_position_over_a_named_variant_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "{0} is not how this is read")]
Arm { root: String },
}
});
assert!(
refusal.contains("a positional placeholder reads a TUPLE variant"),
"{refusal}"
);
}
#[test]
fn a_placeholder_on_a_unit_variant_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "{0} has nowhere to come from")]
Arm,
}
});
assert!(refusal.contains("which has 0"), "{refusal}");
}
#[test]
fn an_unclosed_or_unpaired_brace_is_refused() {
let unclosed = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "a {0 that never closes")]
Arm(u8),
}
});
assert!(unclosed.contains("never closed"), "{unclosed}");
let unpaired = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "a } that opens nothing")]
Arm(u8),
}
});
assert!(unpaired.contains("opens nothing"), "{unpaired}");
}
#[test]
fn a_struct_and_a_union_are_refused() {
let refusal = refused(&syn::parse_quote! {
pub struct WatchError {
root: String,
}
});
assert!(refusal.contains("supports enums only"), "{refusal}");
}
#[test]
fn a_generic_parameter_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError<T> {
#[ingraph(code = "NOPE", error = "{0}")]
Arm(T),
}
});
assert!(refusal.contains("takes no generic parameter"), "{refusal}");
}
#[test]
fn an_argument_on_the_attribute_is_refused() {
let written: syn::DeriveInput = syn::parse_quote! {
#[ingraph(crate = "other::ingraph")]
pub enum WatchError {
#[ingraph(code = "NOPE", error = "one")]
Arm,
}
};
let refusal = refused(&written);
assert!(refusal.contains("takes no arguments"), "{refusal}");
}
#[test]
fn an_unknown_entry_on_a_variant_is_refused() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "NOPE", error = "one", rename = "two")]
Arm,
}
});
assert!(
refusal.contains("unknown entry on a leaf error's variant"),
"{refusal}"
);
}
#[test]
fn each_word_is_written_at_most_once() {
let twice_coded = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "ONE", code = "TWO", error = "one")]
Arm,
}
});
assert!(
twice_coded.contains("`code` is declared more than once"),
"{twice_coded}"
);
let twice_worded = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "ONE", error = "one", error = "two")]
Arm,
}
});
assert!(
twice_worded.contains("`error` is declared more than once"),
"{twice_worded}"
);
}
#[test]
fn a_bad_value_earns_one_error() {
let refusal = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = NOT_A_STRING, error = "one")]
Arm,
}
});
assert_eq!(refusal.lines().count(), 1, "{refusal}");
assert!(refusal.contains("in a string literal"), "{refusal}");
let worded = refused(&syn::parse_quote! {
pub enum WatchError {
#[ingraph(code = "ONE", error = not_a_string)]
Arm,
}
});
assert_eq!(worded.lines().count(), 1, "{worded}");
assert!(
worded.contains("is the sentence this failure renders as"),
"{worded}"
);
}