use async_graphql::InputType;
use super::*;
use crate::{
BytesFilter, FixedBytesFilter, ListFilter, Nullable, ScalarFilter, SetFilter, TextFilter,
};
#[test]
fn the_text_row_takes_the_canonical_name() {
assert_eq!(
<TextFilter<String> as InputType>::type_name(),
"StringFilter"
);
assert_eq!(
<Nullable<TextFilter<String>> as InputType>::type_name(),
"NullableStringFilter"
);
}
#[cfg(feature = "smol_str")]
#[test]
fn the_canonical_text_names_survive_the_axis_for_the_second_text_type() {
assert_eq!(
<TextFilter<smol_str::SmolStr> as InputType>::type_name(),
"TextFilter"
);
assert_eq!(
<Nullable<TextFilter<smol_str::SmolStr>> as InputType>::type_name(),
"NullableTextFilter"
);
}
#[test]
fn the_reading_defaults_to_the_framework() {
fn one_type_under_two_spellings(filter: TextFilter<String, Builtin>) -> TextFilter<String> {
filter
}
let _ = one_type_under_two_spellings(TextFilter::new().with_eq("clapper".to_owned()));
}
#[test]
fn a_collection_of_a_carrier_element_reaches_the_wire() {
assert_eq!(
<ListFilter<u128, ScalarFilter<u128>> as InputType>::type_name(),
"U128ListFilter"
);
assert_eq!(
<SetFilter<u128, ScalarFilter<u128>> as InputType>::type_name(),
"U128SetFilter"
);
const _: InputCrossing<u128> = InputCrossing::WITNESS;
const _: InputCrossing<i128> = InputCrossing::WITNESS;
}
#[test]
fn a_list_of_blobs_crosses_as_hex_and_not_as_integers() {
assert_eq!(
<<Vec<u8> as ToGraphqlInput>::Input as InputType>::type_name(),
"U8Vector"
);
assert_ne!(
<<Vec<u8> as ToGraphqlInput>::Input as InputType>::type_name(),
"[Int!]"
);
}
#[test]
fn the_crossing_is_alias_proof() {
type Uuid7 = u128;
fn one_form_under_two_spellings(
carried: <Uuid7 as ToGraphqlInput>::Input,
) -> <u128 as ToGraphqlInput>::Input {
carried
}
let crossed = one_form_under_two_spellings(crate::U128::from(u128::MAX));
assert_eq!(*crossed.get(), u128::MAX);
}
#[test]
fn an_operand_survives_both_directions() {
let carried = <u128 as ToGraphqlInput>::carry(&u128::MAX);
assert_eq!(<u128 as ToGraphqlInput>::cross(carried), Ok(u128::MAX));
let blob = vec![0x89u8, 0x50, 0x4e, 0x47];
let carried = <Vec<u8> as ToGraphqlInput>::carry(&blob);
assert_eq!(carried.to_string(), "89504e47");
assert_eq!(<Vec<u8> as ToGraphqlInput>::cross(carried), Ok(blob));
}
#[test]
fn a_declarers_own_reading_carries_a_name_and_a_refusal() {
#[derive(Debug, Clone, PartialEq)]
struct Tag(String);
enum TagWire {}
impl TextWire<Tag> for TagWire {
const NAME: &'static str = "TagFilter";
type Carrier = String;
type Error = String;
fn cross(carrier: String) -> Result<Tag, String> {
if carrier.is_empty() {
return Err(String::from("a tag is not empty"));
}
Ok(Tag(carrier))
}
fn carry(operand: &Tag) -> String {
operand.0.clone()
}
}
assert_eq!(
<TextFilter<Tag, TagWire> as InputType>::type_name(),
"TagFilter"
);
assert_eq!(
<Nullable<TextFilter<Tag, TagWire>> as InputType>::type_name(),
"NullableTagFilter"
);
let written = TextFilter::<Tag, TagWire>::new().with_contains(Tag(String::from("cam")));
let read = <TextFilter<Tag, TagWire> as InputType>::parse(Some(written.to_value()))
.expect("a written filter parses");
assert_eq!(read, written);
let refused = <TextFilter<Tag, TagWire> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("eq"),
async_graphql::Value::String(String::new()),
)]
.into_iter()
.collect(),
)))
.expect_err("an empty tag is refused by the reading");
let sentence = refused
.into_server_error(async_graphql::Pos::default())
.message;
assert!(sentence.contains("a tag is not empty"), "{sentence}");
}
#[test]
fn the_crossed_collections_reach_a_schema() {
struct Query;
#[async_graphql::Object]
impl Query {
async fn wide(&self, ids: ListFilter<u128>, id_set: SetFilter<u128>) -> bool {
crate::GraphqlFilter::is_empty(&ids) && crate::GraphqlFilter::is_empty(&id_set)
}
async fn blobs(&self, covers: ListFilter<Vec<u8>>) -> bool {
crate::GraphqlFilter::is_empty(&covers)
}
}
let sdl = async_graphql::Schema::build(
Query,
async_graphql::EmptyMutation,
async_graphql::EmptySubscription,
)
.finish()
.sdl();
assert!(
sdl.contains(
"input U128ListFilter {\n\teq: [u128!]\n\tne: [u128!]\n\tgt: [u128!]\n\tgte: \
[u128!]\n\tlt: [u128!]\n\tlte: [u128!]\n\thasElement: u128\n\tany: \
U128Filter\n\tcount: CountFilter\n}\n"
),
"{sdl}"
);
assert!(
sdl.contains("input U128SetFilter {\n\teq: [u128!]"),
"{sdl}"
);
assert!(
sdl.contains(
"input U8VectorListFilter {\n\teq: [U8Vector!]\n\tne: [U8Vector!]\n\tgt: \
[U8Vector!]\n\tgte: [U8Vector!]\n\tlt: [U8Vector!]\n\tlte: [U8Vector!]\n\thasElement: \
U8Vector\n\tany: U8VectorFilter\n\tcount: CountFilter\n}\n"
),
"{sdl}"
);
assert!(!sdl.contains("eq: [[Int!]!]"), "{sdl}");
assert!(!sdl.contains("hasElement: [Int!]"), "{sdl}");
}
#[test]
fn the_canonical_scalar_and_byte_names_survive_the_axis() {
assert_eq!(<ScalarFilter<i8> as InputType>::type_name(), "I8Filter");
assert_eq!(<ScalarFilter<i16> as InputType>::type_name(), "I16Filter");
assert_eq!(<ScalarFilter<i32> as InputType>::type_name(), "I32Filter");
assert_eq!(<ScalarFilter<i64> as InputType>::type_name(), "I64Filter");
assert_eq!(<ScalarFilter<i128> as InputType>::type_name(), "I128Filter");
assert_eq!(<ScalarFilter<u8> as InputType>::type_name(), "U8Filter");
assert_eq!(<ScalarFilter<u16> as InputType>::type_name(), "U16Filter");
assert_eq!(<ScalarFilter<u32> as InputType>::type_name(), "U32Filter");
assert_eq!(<ScalarFilter<u64> as InputType>::type_name(), "U64Filter");
assert_eq!(<ScalarFilter<u128> as InputType>::type_name(), "U128Filter");
assert_eq!(<ScalarFilter<f32> as InputType>::type_name(), "F32Filter");
assert_eq!(<ScalarFilter<f64> as InputType>::type_name(), "F64Filter");
assert_eq!(
<ScalarFilter<core::num::NonZeroI32> as InputType>::type_name(),
"NonZeroI32Filter"
);
assert_eq!(
<ScalarFilter<core::num::NonZeroU64> as InputType>::type_name(),
"NonZeroU64Filter"
);
assert_eq!(
<ScalarFilter<crate::Timestamp> as InputType>::type_name(),
"TimestampFilter"
);
assert_eq!(
<ScalarFilter<usize> as InputType>::type_name(),
"CountFilter"
);
assert_eq!(
<ScalarFilter<crate::Count> as InputType>::type_name(),
"CardinalityFilter"
);
assert_eq!(
<BytesFilter<::bytes::Bytes> as InputType>::type_name(),
"BytesFilter"
);
assert_eq!(
<Nullable<ScalarFilter<i64>> as InputType>::type_name(),
"NullableI64Filter"
);
assert_eq!(
<Nullable<BytesFilter<::bytes::Bytes>> as InputType>::type_name(),
"NullableBytesFilter"
);
}
#[cfg(feature = "jiff")]
#[test]
fn the_canonical_temporal_names_survive_the_axis() {
assert_eq!(
<ScalarFilter<jiff::Timestamp> as InputType>::type_name(),
"DateTimeFilter"
);
assert_eq!(
<ScalarFilter<jiff::civil::Date> as InputType>::type_name(),
"DateFilter"
);
assert_eq!(
<ScalarFilter<jiff::civil::Time> as InputType>::type_name(),
"TimeFilter"
);
assert_eq!(
<ScalarFilter<jiff::Zoned> as InputType>::type_name(),
"ZonedDateTimeFilter"
);
assert_eq!(
<ScalarFilter<jiff::civil::DateTime> as InputType>::type_name(),
"LocalDateTimeFilter"
);
assert_eq!(
<ScalarFilter<jiff::tz::Offset> as InputType>::type_name(),
"UtcOffsetFilter"
);
}
#[test]
fn the_claimed_byte_vocabularies_carry_their_settled_names() {
assert_eq!(
<BytesFilter<smol_bytes::Bytes> as InputType>::type_name(),
"SmolBytesFilter"
);
assert_eq!(
<BytesFilter<smol_bytes::shared::Bytes> as InputType>::type_name(),
"SmolBytesFilter"
);
assert_eq!(
<TextFilter<smol_bytes::Utf8Bytes> as InputType>::type_name(),
"SmolUtf8BytesFilter"
);
assert_eq!(
<TextFilter<smol_bytes::shared::Utf8Bytes> as InputType>::type_name(),
"SmolUtf8BytesFilter"
);
assert_eq!(
<FixedBytesFilter<[u8; 16], 16> as InputType>::type_name(),
"Fixed16U8ArrayFilter"
);
assert_eq!(
<FixedBytesFilter<[u8; 32], 32> as InputType>::type_name(),
"Fixed32U8ArrayFilter"
);
assert_eq!(
<Nullable<FixedBytesFilter<[u8; 16], 16>> as InputType>::type_name(),
"NullableFixed16U8ArrayFilter"
);
}
#[test]
fn the_default_byte_operand_and_the_named_ones_are_all_different_names() {
assert_eq!(
<BytesFilter<::bytes::Bytes> as InputType>::type_name(),
"BytesFilter"
);
assert_eq!(
<BytesFilter<Vec<u8>> as InputType>::type_name(),
"U8VectorFilter"
);
assert_ne!(
<BytesFilter<::bytes::Bytes> as InputType>::type_name(),
<BytesFilter<Vec<u8>> as InputType>::type_name()
);
assert_ne!(
<BytesFilter<::bytes::Bytes> as InputType>::type_name(),
<BytesFilter<smol_bytes::Bytes> as InputType>::type_name()
);
}
#[test]
fn a_claimed_operand_survives_both_directions() {
let digest: [u8; 4] = [0x89, 0x50, 0x4e, 0x47];
let carried = <Builtin as BytesWire<[u8; 4]>>::carry(&digest);
assert_eq!(
<Builtin as BytesWire<[u8; 4]>>::cross(carried).expect("a four-byte value fits"),
digest
);
let text = smol_bytes::shared::Utf8Bytes::from(String::from("a label"));
let carried = <Builtin as TextWire<smol_bytes::shared::Utf8Bytes>>::carry(&text);
assert_eq!(carried, "a label");
assert_eq!(
<Builtin as TextWire<smol_bytes::shared::Utf8Bytes>>::cross(carried)
.expect("a text crossing cannot refuse"),
text
);
let blob = smol_bytes::shared::Bytes::from(vec![0x0d, 0x0a]);
let carried = <Builtin as BytesWire<smol_bytes::shared::Bytes>>::carry(&blob);
assert_eq!(
<Builtin as BytesWire<smol_bytes::shared::Bytes>>::cross(carried)
.expect("a blob crossing cannot refuse"),
blob
);
}
#[test]
fn a_fixed_width_column_refuses_the_wrong_number_of_bytes() {
let short = <Builtin as BytesWire<[u8; 16]>>::cross(crate::FixedU8Array::from(vec![0u8; 15]))
.expect_err("fifteen bytes do not fit a sixteen-byte column");
assert_eq!(short.expected(), 16);
assert_eq!(short.got(), 15);
assert_eq!(short.to_string(), "expected 16 bytes, got 15");
let long = <Builtin as BytesWire<[u8; 16]>>::cross(crate::FixedU8Array::from(vec![0u8; 17]))
.expect_err("seventeen bytes do not fit either");
assert_eq!(long.to_string(), "expected 16 bytes, got 17");
}
#[expect(
dead_code,
reason = "a signature is the assertion — its `where` clause is what demands the rows, and calling \
it would prove nothing the compiler has not already proved"
)]
fn every_builtin_reading_carries_a_face()
where
ScalarFilter<i8>: InputType,
ScalarFilter<i16>: InputType,
ScalarFilter<i32>: InputType,
ScalarFilter<i64>: InputType,
ScalarFilter<i128>: InputType,
ScalarFilter<u8>: InputType,
ScalarFilter<u16>: InputType,
ScalarFilter<u32>: InputType,
ScalarFilter<u64>: InputType,
ScalarFilter<u128>: InputType,
ScalarFilter<f32>: InputType,
ScalarFilter<f64>: InputType,
ScalarFilter<core::num::NonZeroI8>: InputType,
ScalarFilter<core::num::NonZeroI16>: InputType,
ScalarFilter<core::num::NonZeroI32>: InputType,
ScalarFilter<core::num::NonZeroI64>: InputType,
ScalarFilter<core::num::NonZeroU8>: InputType,
ScalarFilter<core::num::NonZeroU16>: InputType,
ScalarFilter<core::num::NonZeroU32>: InputType,
ScalarFilter<core::num::NonZeroU64>: InputType,
ScalarFilter<core::num::NonZeroI128>: InputType,
ScalarFilter<core::num::NonZeroU128>: InputType,
ScalarFilter<std::net::Ipv4Addr>: InputType,
ScalarFilter<std::net::Ipv6Addr>: InputType,
ScalarFilter<std::net::IpAddr>: InputType,
ScalarFilter<std::net::SocketAddrV4>: InputType,
ScalarFilter<std::net::SocketAddrV6>: InputType,
ScalarFilter<std::net::SocketAddr>: InputType,
ListFilter<std::net::Ipv4Addr>: InputType,
ListFilter<std::net::SocketAddr>: InputType,
ListFilter<core::num::NonZeroU32>: InputType,
crate::ConfidenceFilter: InputType,
ScalarFilter<crate::Timestamp>: InputType,
ScalarFilter<usize>: InputType,
BytesFilter<Vec<u8>>: InputType,
FixedBytesFilter<[u8; 16], 16>: InputType,
BytesFilter<smol_bytes::Bytes>: InputType,
TextFilter<smol_bytes::Utf8Bytes>: InputType,
ListFilter<[u8; 16]>: InputType,
ListFilter<smol_bytes::Bytes>: InputType,
ListFilter<smol_bytes::Utf8Bytes>: InputType,
Nullable<ScalarFilter<i64>>: InputType,
Nullable<BytesFilter<Vec<u8>>>: InputType,
{
}
#[expect(
dead_code,
reason = "a signature is the assertion — see `every_builtin_reading_carries_a_face`"
)]
fn the_bytes_crates_rows_carry_a_face()
where
BytesFilter<::bytes::Bytes>: InputType,
ListFilter<::bytes::Bytes>: InputType,
{
}
#[test]
fn the_scalar_and_byte_readings_default_to_the_framework() {
fn one_scalar_under_two_spellings(filter: ScalarFilter<i64, Builtin>) -> ScalarFilter<i64> {
filter
}
fn one_blob_under_two_spellings(filter: BytesFilter<Vec<u8>, Builtin>) -> BytesFilter<Vec<u8>> {
filter
}
fn one_fixed_column_under_two_spellings(
filter: FixedBytesFilter<[u8; 32], 32, Builtin>,
) -> FixedBytesFilter<[u8; 32], 32> {
filter
}
let _ = one_scalar_under_two_spellings(ScalarFilter::new().with_eq(24));
let _ = one_blob_under_two_spellings(BytesFilter::new().with_eq(vec![0x89]));
let _ = one_fixed_column_under_two_spellings(FixedBytesFilter::new());
}
#[test]
fn a_declarers_own_scalar_and_byte_readings_carry_a_name_and_a_refusal() {
#[derive(Debug, Clone, Copy, PartialEq)]
struct Rate(u32);
enum RateWire {}
impl ScalarWire<Rate> for RateWire {
const NAME: &'static str = "RateFilter";
type Carrier = crate::U32;
type Error = String;
fn cross(carrier: crate::U32) -> Result<Rate, String> {
match u32::from(carrier) {
0 => Err(String::from("a rate of zero is not a rate")),
rate => Ok(Rate(rate)),
}
}
fn carry(operand: &Rate) -> crate::U32 {
crate::U32::from(operand.0)
}
}
#[derive(Debug, Clone, PartialEq)]
struct Sum(Vec<u8>);
enum SumWire {}
impl BytesWire<Sum> for SumWire {
const NAME: &'static str = "SumFilter";
type Carrier = HexBytes;
type Error = String;
fn cross(carrier: HexBytes) -> Result<Sum, String> {
let bytes = Vec::from(carrier);
if bytes.len() == 4 {
return Ok(Sum(bytes));
}
Err(String::from("a checksum is 4 bytes"))
}
fn carry(operand: &Sum) -> HexBytes {
HexBytes::from(operand.0.clone())
}
}
assert_eq!(
<ScalarFilter<Rate, RateWire> as InputType>::type_name(),
"RateFilter"
);
assert_eq!(
<Nullable<ScalarFilter<Rate, RateWire>> as InputType>::type_name(),
"NullableRateFilter"
);
assert_eq!(
<BytesFilter<Sum, SumWire> as InputType>::type_name(),
"SumFilter"
);
assert_eq!(
<FixedBytesFilter<Sum, 4, SumWire> as InputType>::type_name(),
"Fixed4SumFilter"
);
assert_eq!(
<FixedBytesFilter<Sum, 32, SumWire> as InputType>::type_name(),
"Fixed32SumFilter"
);
assert_eq!(
<Nullable<FixedBytesFilter<Sum, 4, SumWire>> as InputType>::type_name(),
"NullableFixed4SumFilter"
);
let written = ScalarFilter::<Rate, RateWire>::new()
.with_gte(Rate(3))
.with_in_([Rate(7), Rate(9)]);
let read = <ScalarFilter<Rate, RateWire> as InputType>::parse(Some(written.to_value()))
.expect("a written filter parses");
assert_eq!(read, written);
let refused =
<ScalarFilter<Rate, RateWire> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("in"),
async_graphql::Value::List(vec![
async_graphql::Value::Number(7.into()),
async_graphql::Value::Number(0.into()),
]),
)]
.into_iter()
.collect(),
)))
.expect_err("a zero rate is refused by the reading");
let sentence = refused
.into_server_error(async_graphql::Pos::default())
.message;
assert!(
sentence.contains("a rate of zero is not a rate"),
"{sentence}"
);
let refused =
<BytesFilter<Sum, SumWire> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("eq"),
async_graphql::Value::String(String::from("dead")),
)]
.into_iter()
.collect(),
)))
.expect_err("a two-byte checksum is refused by the reading");
let sentence = refused
.into_server_error(async_graphql::Pos::default())
.message;
assert!(sentence.contains("a checksum is 4 bytes"), "{sentence}");
}
#[test]
fn a_wire_zero_is_refused_by_name_at_both_nonzero_legs() {
use core::num::NonZeroU32;
let refused = <ScalarFilter<NonZeroU32> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("eq"),
async_graphql::Value::Number(0.into()),
)]
.into_iter()
.collect(),
)))
.expect_err("a zero operand is refused by the reading");
let sentence = refused
.into_server_error(async_graphql::Pos::default())
.message;
assert!(sentence.contains("NonZeroU32"), "{sentence}");
assert!(sentence.contains("REFUSED and never wrapped"), "{sentence}");
let refused = <ListFilter<NonZeroU32> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("hasElement"),
async_graphql::Value::Number(0.into()),
)]
.into_iter()
.collect(),
)))
.expect_err("a zero member is refused by the element crossing");
let sentence = refused
.into_server_error(async_graphql::Pos::default())
.message;
assert!(sentence.contains("NonZeroU32"), "{sentence}");
let accepted =
<ScalarFilter<NonZeroU32> as InputType>::parse(Some(async_graphql::Value::Object(
[(
async_graphql::Name::new("eq"),
async_graphql::Value::Number(24.into()),
)]
.into_iter()
.collect(),
)))
.expect("a non-zero operand crosses");
assert_eq!(
ScalarFilter::eq(&accepted),
Some(&NonZeroU32::new(24).expect("24 is not zero"))
);
let one = NonZeroU32::new(1).expect("1 is not zero");
assert_eq!(
<Builtin as ScalarWire<NonZeroU32>>::carry(&one),
crate::U32::from(1)
);
assert_eq!(
<NonZeroU32 as ToGraphqlInput>::carry(&one),
crate::U32::from(1)
);
}
#[test]
fn a_nonzero_width_crosses_on_its_own_integers_scalar() {
assert_eq!(
<ScalarFilter<core::num::NonZeroU32> as InputType>::type_name(),
"NonZeroU32Filter"
);
assert_eq!(
<<Builtin as ScalarWire<core::num::NonZeroU32>>::Carrier as InputType>::type_name(),
"u32"
);
assert_eq!(
<ScalarFilter<core::num::NonZeroI128> as InputType>::type_name(),
"NonZeroI128Filter"
);
assert_eq!(
<<Builtin as ScalarWire<core::num::NonZeroI128>>::Carrier as InputType>::type_name(),
"i128"
);
}
#[test]
fn the_address_family_publishes_pascal_names() {
assert_eq!(
<ScalarFilter<std::net::Ipv4Addr> as InputType>::type_name(),
"Ipv4AddrFilter"
);
assert_eq!(
<ScalarFilter<std::net::Ipv6Addr> as InputType>::type_name(),
"Ipv6AddrFilter"
);
assert_eq!(
<ScalarFilter<std::net::IpAddr> as InputType>::type_name(),
"IpAddrFilter"
);
assert_eq!(
<ScalarFilter<std::net::SocketAddrV4> as InputType>::type_name(),
"SocketAddrV4Filter"
);
assert_eq!(
<ScalarFilter<std::net::SocketAddrV6> as InputType>::type_name(),
"SocketAddrV6Filter"
);
assert_eq!(
<ScalarFilter<std::net::SocketAddr> as InputType>::type_name(),
"SocketAddrFilter"
);
assert_eq!(
<Nullable<ScalarFilter<std::net::Ipv4Addr>> as InputType>::type_name(),
"NullableIpv4AddrFilter"
);
}
#[test]
fn a_cardinality_crosses_on_the_hybrid_u64_carrier_at_every_magnitude() {
use crate::{Count, ToGraphqlInput, ToGraphqlOutput};
const SAFE: u64 = (1 << 53) - 1;
for magnitude in [42_u64, 5_000_000_000, SAFE + 2, u64::MAX] {
let count = Count::new(magnitude);
assert_eq!(
u64::from(<Count as ToGraphqlOutput>::to_graphql_output(&count)),
magnitude,
"the OUTPUT direction carries the whole width"
);
assert_eq!(
u64::from(<Count as ToGraphqlInput>::carry(&count)),
magnitude,
"and so does the INPUT direction's write-back"
);
assert_eq!(
<Count as ToGraphqlInput>::cross(<Count as ToGraphqlInput>::carry(&count)),
Ok(count),
"which makes the pair a round trip"
);
}
assert_eq!(
<Builtin as ScalarWire<Count>>::cross(<Builtin as ScalarWire<Count>>::carry(&Count::new(9))),
Ok(Count::new(9))
);
}