use ingraph_codegen::{extension::Extension, index::IndexModel, prelude::NodeKind};
use super::tests::refused;
fn blob(input: &syn::DeriveInput) -> syn::Result<IndexModel> {
let (host, arguments) = crate::host::split(input);
super::super::index::parse(&host, &arguments, NodeKind::Blob)
}
fn family(head: &str) -> syn::DeriveInput {
let head: proc_macro2::TokenStream = head.parse().expect("a head");
syn::parse_quote! {
#[ingraph(upstream(node = "video::Keyframe", payload = "pixels"), #head)]
pub struct Thumbnail {
#[ingraph(repeated)]
payload: Vec<u8>,
}
}
}
fn accepted(head: &str) -> IndexModel {
blob(&family(head)).expect("the declaration is accepted")
}
fn refusal(head: &str) -> String {
refused(family(head), NodeKind::Blob)
}
fn stores(model: &IndexModel) -> Vec<String> {
model
.stores
.iter()
.map(|engine| engine.word.to_string())
.collect()
}
#[test]
fn a_shipped_store_word_is_read_at_the_head() {
let model = accepted("fs");
assert_eq!(stores(&model), ["fs"]);
let upstream = &model.source.node;
assert_eq!(
quote::quote!(#upstream).to_string().replace(' ', ""),
"video::Keyframe"
);
}
#[test]
fn a_third_party_store_word_is_admitted_at_the_head() {
assert_eq!(stores(&accepted("s3")), ["s3"]);
}
#[test]
fn several_stores_are_declared_portability_in_written_order() {
assert_eq!(stores(&accepted("fs, s3, gcs")), ["fs", "s3", "gcs"]);
}
#[test]
fn a_stores_own_knobs_are_carried_uninterpreted() {
let model = accepted(r#"s3(bucket = "cards", region = "eu-west-1")"#);
assert_eq!(stores(&model), ["s3"]);
let carried = model.stores[0].options.to_string().replace(' ', "");
assert!(carried.contains("bucket=\"cards\""), "{carried}");
assert!(carried.contains("region=\"eu-west-1\""), "{carried}");
}
#[test]
fn a_family_may_declare_no_store_at_all() {
assert!(stores(&accepted(r#"extension = "png""#)).is_empty());
}
#[test]
fn a_full_texts_engine_on_an_artifact_family_is_refused_by_name() {
let e = refusal("tantivy");
assert!(
e.contains("`tantivy` is the engine `ingraph` ships for"),
"{e}"
);
assert!(e.contains("full-text indexes"), "{e}");
assert!(
e.contains("engines(tantivy_of_mine = \"path::To::Store\")"),
"{e}"
);
}
#[test]
fn a_repeated_store_word_is_refused() {
let e = refusal("fs, fs");
assert!(e.contains("`fs` is declared more than once"), "{e}");
assert!(e.contains("declared PORTABILITY"), "{e}");
}
#[test]
fn a_store_written_as_a_key_value_is_refused() {
let e = refusal(r#"s3 = "bucket""#);
assert!(
e.contains("`s3` is a STORE and a store is declared as a BLOCK"),
"{e}"
);
assert!(e.contains("belongs to the store"), "{e}");
}
#[test]
fn a_path_at_the_head_names_no_store() {
let e = refusal("app::S3");
assert!(e.contains("an engine is named by ONE word"), "{e}");
assert!(e.contains("a NAME the deployment binds"), "{e}");
}
#[test]
fn fanout_on_an_artifact_family_names_its_own_deferral() {
let e = refusal("fs, s3, fanout");
assert!(e.contains("answers an ADDRESS"), "{e}");
assert!(e.contains("recorded"), "{e}");
assert!(e.contains("declared PORTABILITY"), "{e}");
}
#[test]
fn a_static_extension_is_one_suffix_for_the_family() {
let model = accepted(r#"fs, extension = "png""#);
let suffix = model
.extension
.as_ref()
.and_then(Extension::statik)
.expect("the static form");
assert_eq!(suffix.value(), "png");
assert_eq!(stores(&model), ["fs"]);
}
#[test]
fn an_omitted_extension_is_extensionless_storage() {
assert!(accepted("fs").extension.is_none());
}
#[test]
fn a_string_column_decides_the_suffix_and_any_of_fences_it() {
let model = accepted(r#"fs, extension(from = "format", any_of = ["png", "jpg"])"#);
let column = model
.extension
.as_ref()
.and_then(Extension::column)
.expect("the block form");
assert_eq!(column.source.field(), "format");
assert!(
column.source.enumerated().is_none(),
"the string road names no type"
);
assert_eq!(
column
.any_of
.iter()
.map(syn::LitStr::value)
.collect::<Vec<_>>(),
["png", "jpg"]
);
assert!(column.variants.is_empty());
assert!(column.with.is_none());
}
#[test]
fn an_enum_column_names_its_type_explicitly() {
let model =
accepted(r#"fs, extension(from(field = "format", type = "app::media::ImageFormat"))"#);
let column = model
.extension
.as_ref()
.and_then(Extension::column)
.expect("the block form");
assert_eq!(column.source.field(), "format");
let ty = column
.source
.enumerated()
.expect("the enum road names its type");
assert_eq!(
quote::quote!(#ty).to_string().replace(' ', ""),
"app::media::ImageFormat"
);
assert!(column.any_of.is_empty());
}
#[test]
fn an_enum_subset_is_named_by_full_variant_paths() {
let model = accepted(
r#"fs, extension(from(field = "format", type = "app::Format"), variants = ["app::Format::Png", "app::Format::Jpg"])"#,
);
let column = model
.extension
.as_ref()
.and_then(Extension::column)
.expect("the block form");
assert_eq!(
column
.variants
.iter()
.map(syn::LitStr::value)
.collect::<Vec<_>>(),
["app::Format::Png", "app::Format::Jpg"]
);
}
#[test]
fn a_hook_composes_with_both_fences() {
let model = accepted(
r#"fs, extension(from(field = "format", type = "app::Format"), variants = ["app::Format::Png"], any_of = ["png"], with = "app::suffix_of")"#,
);
let column = model
.extension
.as_ref()
.and_then(Extension::column)
.expect("the block form");
let with = column.with.as_ref().expect("the hook");
assert_eq!(
quote::quote!(#with).to_string().replace(' ', ""),
"app::suffix_of"
);
assert_eq!(column.variants.len(), 1);
assert_eq!(column.any_of.len(), 1);
}
#[test]
fn a_bare_array_of_suffixes_is_refused_because_it_decides_nothing() {
let e = refusal(r#"fs, extension = ["png", "jpg"]"#);
assert!(e.contains("says nothing about which one an entry"), "{e}");
assert!(e.contains("a set is not a decision"), "{e}");
assert!(e.contains("from = \"<column>\""), "{e}");
}
#[test]
fn a_parenthesized_single_suffix_is_refused() {
let e = refusal(r#"fs, extension("png")"#);
assert!(e.contains("is a single fact written as a block"), "{e}");
assert!(e.contains("`extension = \"png\"`"), "{e}");
}
#[test]
fn a_string_column_without_any_of_is_refused() {
let e = refusal(r#"fs, extension(from = "format")"#);
assert!(e.contains("a STRING column needs `any_of`"), "{e}");
assert!(e.contains("its own variants are the set"), "{e}");
}
#[test]
fn variants_on_a_string_column_is_refused() {
let e =
refusal(r#"fs, extension(from = "format", any_of = ["png"], variants = ["app::Format::Png"])"#);
assert!(
e.contains("fences the INPUT by naming a type's variants"),
"{e}"
);
assert!(e.contains("a string column has none"), "{e}");
}
#[test]
fn a_variant_of_another_type_is_refused() {
let e = refusal(
r#"fs, extension(from(field = "format", type = "app::Format"), variants = ["other::Codec::Png"])"#,
);
assert!(e.contains("is not a variant of `app::Format`"), "{e}");
assert!(e.contains("FULL path under that type"), "{e}");
}
#[test]
fn an_enum_road_missing_its_type_is_refused() {
let e = refusal(r#"fs, extension(from(field = "format"))"#);
assert!(e.contains("`type` is not written"), "{e}");
assert!(
e.contains("a string column takes the shorter spelling"),
"{e}"
);
}
#[test]
fn an_extension_block_with_no_column_is_refused() {
let e = refusal(r#"fs, extension(any_of = ["png"])"#);
assert!(e.contains("`from` is where it names one"), "{e}");
assert!(e.contains("has nothing to decide by"), "{e}");
}
#[test]
fn an_empty_fence_is_refused() {
let e = refusal(r#"fs, extension(from = "format", any_of = [])"#);
assert!(e.contains("fences nothing in"), "{e}");
assert!(e.contains("Leave the word out"), "{e}");
}
#[test]
fn a_suffix_that_could_not_end_an_address_is_refused() {
for written in [
r#"extension = "a/b""#,
r#"extension = """#,
r#"extension = "..""#,
] {
let e = refusal(&format!("fs, {written}"));
assert!(e.contains("cannot end an address"), "{written}: {e}");
assert!(e.contains("invent a directory level"), "{written}: {e}");
}
}
#[test]
fn a_bare_extension_word_is_refused_with_its_three_forms() {
let e = refusal("fs, extension");
assert!(e.contains("says nothing on its own"), "{e}");
assert!(e.contains("LEAVE IT OUT for extensionless storage"), "{e}");
}
#[test]
fn a_repeated_extension_is_refused() {
let e = refusal(r#"fs, extension = "png", extension = "jpg""#);
assert!(e.contains("`extension` is declared more than once"), "{e}");
}
#[test]
fn an_unknown_entry_in_the_block_names_the_four_keys() {
let e = refusal(r#"fs, extension(from = "format", any_of = ["png"], suffix = "x")"#);
assert!(e.contains("unknown entry in `extension(…)`"), "{e}");
assert!(e.contains("Four keys, each one meaning"), "{e}");
}
#[test]
fn extension_on_another_kind_is_refused_by_name() {
let document: syn::DeriveInput = syn::parse_quote! {
#[ingraph(upstream(node = "asr::Segment", body = "text"), dedup(hash), extension = "png")]
pub struct SearchDocument {
#[ingraph(searchable)]
body: String,
}
};
let e = refused(document, NodeKind::Fulltext);
assert!(
e.contains("`extension` is an ARTIFACT FAMILY's word"),
"{e}"
);
assert!(e.contains("no addresses to end"), "{e}");
}
#[test]
fn the_data_word_is_read_at_the_head() {
let model = accepted("fs, data");
assert!(model.data);
assert_eq!(stores(&model), ["fs"]);
}
#[test]
fn an_omitted_data_word_serves_the_address_alone() {
assert!(!accepted("fs").data);
}
#[test]
fn data_eats_neither_the_store_word_nor_the_extension_block() {
let model = accepted(r#"fs, data, extension(from = "format", any_of = ["png", "jpg"])"#);
assert!(model.data);
assert_eq!(stores(&model), ["fs"]);
let column = model
.extension
.as_ref()
.and_then(Extension::column)
.expect("the block form");
assert_eq!(column.source.field(), "format");
assert_eq!(column.any_of.len(), 2);
}
#[test]
fn a_repeated_data_word_is_refused() {
let e = refusal("fs, data, data");
assert!(e.contains("`data` is declared more than once"), "{e}");
assert!(e.contains("the word is PRESENCE"), "{e}");
}
#[test]
fn a_data_word_that_carries_anything_is_refused() {
for written in [r#"data = "inline""#, "data()", "data(limit = 4096)"] {
let e = refusal(&format!("fs, {written}"));
assert!(e.contains("`data` is a BARE word"), "{written}: {e}");
assert!(e.contains("nothing for it to carry"), "{written}: {e}");
}
}
#[test]
fn data_on_another_kind_is_refused_by_name() {
let document: syn::DeriveInput = syn::parse_quote! {
#[ingraph(upstream(node = "asr::Segment", body = "text"), dedup(hash), data)]
pub struct SearchDocument {
#[ingraph(searchable)]
body: String,
}
};
let e = refused(document, NodeKind::Fulltext);
assert!(e.contains("`data` is an ARTIFACT FAMILY's word"), "{e}");
assert!(e.contains("no bytes to send"), "{e}");
}