use super::{Gate, Kits, NewTypeModel, ScalarKit};
use crate::{element::ElementFamily, model::DatabaseKind};
fn tight(tokens: impl quote::ToTokens) -> String {
tokens.to_token_stream().to_string().replace(' ', "")
}
fn model(inner: syn::Type, kits: Kits) -> NewTypeModel {
NewTypeModel {
vis: syn::parse_quote!(pub),
subject: syn::Ident::new("Tag", proc_macro2::Span::call_site()),
generics: syn::Generics::default(),
krate: syn::parse_quote!(::ingraph),
member: syn::Member::Unnamed(syn::Index {
index: 0,
span: proc_macro2::Span::call_site(),
}),
inner,
kits,
}
}
fn whole() -> NewTypeModel {
model(
syn::parse_quote!(String),
Kits {
scalar: Some(ScalarKit {
rename: None,
gate: Some(Gate::Parse(syn::parse_quote!(door))),
}),
input: true,
output: true,
marker: Some(ElementFamily::String),
filter: true,
cursor: true,
databases: vec![DatabaseKind::Sqlite, DatabaseKind::Postgres],
},
)
}
#[test]
fn no_delegation_is_written_as_a_bare_method_call() {
let rendered = tight(whole().emit());
for (at, _) in rendered.match_indices("self.0.") {
let tail = &rendered[at + "self.0.".len()..];
assert!(
!tail.starts_with(|c: char| c.is_ascii_alphabetic() || c == '_'),
"a bare method call on the wrapped value: …{}…",
&rendered[at..(at + 60).min(rendered.len())]
);
}
}
#[test]
fn every_row_reaches_the_wrapped_type_through_its_trait() {
let rendered = tight(whole().emit());
for qualified in [
"<Stringas::ingraph::__private::cursor::CursorValue>::write_cursor",
"<Stringas::ingraph::__private::cursor::CursorValue>::read_cursor",
"<Stringas::ingraph::__private::column::ColumnKind>::SEGMENTS",
"<Stringas::ingraph::__private::comparison::sql::Carrier<::ingraph::__private::sqlx::Sqlite>>::push_bind",
"<Stringas::ingraph::__private::sqlx::Type<::ingraph::__private::sqlx::Sqlite>>::type_info",
"<Stringas::ingraph::__private::sqlx::Encode<'__ingraph,::ingraph::__private::sqlx::Sqlite>>::produces",
] {
assert!(rendered.contains(qualified), "missing `{qualified}`");
}
}
#[test]
fn the_encode_row_forwards_every_method() {
let rendered = tight(whole().emit());
for method in [
"fnencode(",
"fnencode_by_ref(",
"fnproduces(",
"fnsize_hint(",
] {
assert!(rendered.contains(method), "`Encode` is missing `{method}`");
}
}
#[test]
fn an_unnamed_kit_emits_nothing() {
let lone = tight(
model(
syn::parse_quote!(u64),
Kits {
input: true,
..Kits::default()
},
)
.emit(),
);
assert!(lone.contains("ToGraphqlInput"));
for absent in [
"ScalarType",
"CursorValue",
"ColumnKind",
"DefaultMarker",
"Carrier",
"Assemble",
"ToGraphqlOutput",
] {
assert!(!lone.contains(absent), "an unnamed kit emitted `{absent}`");
}
}
#[test]
fn each_row_rides_the_gate_its_names_need() {
let rendered = tight(whole().emit());
for gate in [
"::ingraph::__private::gate::if_async_graphql!",
"::ingraph::__private::gate::if_sqlx!",
"::ingraph::__private::gate::if_sqlite!",
"::ingraph::__private::gate::if_postgres!",
] {
assert!(rendered.contains(gate), "missing `{gate}`");
}
}
#[test]
fn the_reading_is_the_one_name_outside_the_anonymous_const() {
let rendered = tight(whole().emit());
let (before, _) = rendered
.split_once("const_:()={")
.expect("the emission opens an anonymous const");
assert!(before.contains("pubenumTagWire{}"), "{before}");
let private = tight(
NewTypeModel {
vis: syn::parse_quote!(pub(crate)),
..whole()
}
.emit(),
);
assert!(private.contains("pub(crate)enumTagWire{}"), "{private}");
}
#[test]
fn the_reading_publishes_the_operands_name_and_follows_a_rename() {
assert!(
tight(whole().emit()).contains(r#"constNAME:&'static::core::primitive::str="TagFilter""#)
);
let renamed = NewTypeModel {
kits: Kits {
scalar: Some(ScalarKit {
rename: Some("Label".to_owned()),
gate: None,
}),
..whole().kits
},
..whole()
};
let rendered = tight(renamed.emit());
assert!(
rendered.contains(r#"name="Label""#),
"the scalar's own name"
);
assert!(
rendered.contains(r#"constNAME:&'static::core::primitive::str="LabelFilter""#),
"the filter's name follows it"
);
}
#[test]
fn the_enumeration_family_names_its_filter_directly() {
let rendered = tight(
model(
syn::parse_quote!(u32),
Kits {
marker: Some(ElementFamily::Enum),
filter: true,
..Kits::default()
},
)
.emit(),
);
assert!(
!rendered.contains("TagWire"),
"no reading is minted: {rendered}"
);
assert!(rendered.contains("typeFilter=::ingraph::__private::graphql::EnumFilter<Tag>;"));
}
#[test]
fn the_crossing_form_forks_on_the_scalar() {
let faced = tight(whole().emit());
assert!(faced.contains("typeInput=Tag;"), "{faced}");
let transparent = tight(
model(
syn::parse_quote!(u64),
Kits {
input: true,
..Kits::default()
},
)
.emit(),
);
assert!(
transparent.contains("typeInput=<u64as::ingraph::__private::graphql::ToGraphqlInput>::Input;"),
"{transparent}"
);
}
#[test]
fn the_door_is_named_by_every_read_path_and_by_no_write() {
let rendered = tight(whole().emit());
assert_eq!(
rendered.matches("door(").count(),
6,
"two wire legs, the cursor, the row read, and one decode per dialect: {rendered}"
);
let doorless = tight(
NewTypeModel {
kits: Kits {
scalar: Some(ScalarKit::default()),
..whole().kits
},
..whole()
}
.emit(),
);
assert!(
!doorless.contains("door("),
"a declaration with no door names none"
);
}
#[test]
fn no_emitted_path_reaches_the_framework_without_the_shelf() {
let rendered = tight(whole().emit());
let unshelved = rendered.replace("::ingraph::__private::", "\u{1}");
for direct in [
"::ingraph::CursorValue",
"::ingraph::ColumnKind",
"::ingraph::Assemble",
"::ingraph::DefaultMarker",
"::ingraph::ToGraphqlInput",
"::ingraph::ToGraphqlOutput",
"::ingraph::TextFilter",
"::ingraph::sqlx",
"::async_graphql::",
] {
assert!(
!unshelved.contains(direct),
"`{direct}` is reached around the shelf"
);
}
}
#[test]
fn a_named_member_is_reached_by_name() {
let bound = tight(
NewTypeModel {
member: syn::Member::Named(syn::Ident::new("text", proc_macro2::Span::call_site())),
..whole()
}
.emit(),
);
assert!(bound.contains("&self.text"), "{bound}");
let built = tight(
NewTypeModel {
member: syn::Member::Named(syn::Ident::new("text", proc_macro2::Span::call_site())),
kits: Kits {
input: true,
..Kits::default()
},
..whole()
}
.emit(),
);
assert!(built.contains("Self{text:__ingraph_inner}"), "{built}");
}
#[test]
fn a_parameterised_declaration_carries_its_bounds_onto_every_row() {
let rendered = tight(
NewTypeModel {
generics: syn::parse_quote!(<S: Unit>),
inner: syn::parse_quote!(S),
..whole()
}
.emit(),
);
assert!(rendered.contains("forTag<S>"), "{rendered}");
assert!(
rendered.contains("S:::ingraph::__private::cursor::CursorValue"),
"the row's own obligation is a `where` predicate on the wrapped type: {rendered}"
);
assert!(
rendered.contains("<Sas::ingraph::__private::cursor::CursorValue>::write_cursor"),
"and the call names it: {rendered}"
);
}