use async_graphql::{ScalarType, Value};
use super::{Digits, HexBytes, I128, U128};
fn rendered<T: ScalarType>(value: T) -> String {
match value.to_value() {
Value::String(text) => text,
other => panic!("a carrier renders as a string: {other}"),
}
}
fn refusal<T: ScalarType + async_graphql::InputType>(value: Value) -> Option<String> {
<T as ScalarType>::parse(value).err().map(|error| {
error
.into_server_error(async_graphql::parser::Pos::default())
.message
})
}
#[test]
fn the_stack_buffer_holds_both_extremes() {
assert_eq!(Digits::unsigned(u128::MAX).as_str().len(), 39);
assert_eq!(Digits::signed(i128::MIN).as_str().len(), 40);
assert_eq!(Digits::unsigned(0).as_str(), "0");
assert_eq!(Digits::signed(0).as_str(), "0");
assert_eq!(Digits::signed(-1).as_str(), "-1");
assert_eq!(
Digits::unsigned(u128::MAX).as_str(),
"340282366920938463463374607431768211455"
);
assert_eq!(
Digits::signed(i128::MIN).as_str(),
"-170141183460469231731687303715884105728"
);
assert_eq!(
Digits::signed(i128::MAX).as_str(),
"170141183460469231731687303715884105727"
);
}
#[test]
fn a_128_bit_integer_round_trips_through_whichever_form_it_takes() {
for value in [0, 1, u128::from(u64::MAX) + 1, u128::MAX] {
let wire = U128::from(value).to_value();
assert_eq!(
U128::parse(wire.clone()).expect("its own rendering parses"),
U128::from(value),
"{wire}"
);
let text = U128::from(value).to_string();
assert_eq!(
U128::parse(Value::String(text.clone())).expect("the digits parse at any magnitude"),
U128::from(value),
"{text}"
);
}
for value in [0, -1, i128::from(i64::MIN) - 1, i128::MIN, i128::MAX] {
let wire = I128::from(value).to_value();
assert_eq!(
I128::parse(wire.clone()).expect("its own rendering parses"),
I128::from(value),
"{wire}"
);
let text = I128::from(value).to_string();
assert_eq!(
I128::parse(Value::String(text.clone())).expect("the digits parse at any magnitude"),
I128::from(value),
"{text}"
);
}
assert_eq!(
U128::from(u128::MAX).to_string(),
rendered(U128::from(u128::MAX))
);
assert_eq!(
I128::from(i128::MIN).to_string(),
rendered(I128::from(i128::MIN))
);
}
#[test]
fn a_leading_plus_is_read_and_not_rendered() {
let parsed = I128::parse(Value::String(String::from("+7"))).expect("a signed literal");
assert_eq!(parsed, I128::from(7));
assert_eq!(parsed.to_value(), Value::Number(7.into()));
assert_eq!(parsed.to_string(), "7");
}
#[test]
fn a_json_number_is_read_at_a_128_bit_width_when_it_is_whole_and_in_range() {
assert_eq!(
U128::parse(Value::Number(7.into())).expect("a whole number in range"),
U128::from(7),
);
assert_eq!(
I128::parse(Value::Number((-7).into())).expect("a whole number in range"),
I128::from(-7),
);
assert!(U128::is_valid(&Value::Number(7.into())));
let negative = refusal::<U128>(Value::Number((-1).into())).expect("-1 is not a `u128`");
assert!(negative.contains("`u128`"), "{negative}");
assert!(negative.contains("WHOLE value"), "{negative}");
let fraction = refusal::<I128>(Value::Number(
async_graphql::Number::from_f64(1.5).expect("1.5 is a JSON number"),
))
.expect("1.5 is not an integer");
assert!(fraction.contains("DECIMAL TEXT"), "{fraction}");
assert!(refusal::<U128>(Value::Boolean(true)).is_some());
assert!(!U128::is_valid(&Value::Boolean(true)));
}
#[test]
fn a_refused_operand_is_told_what_the_form_and_the_range_are() {
let past = refusal::<U128>(Value::String(String::from(
"340282366920938463463374607431768211456",
)))
.expect("one past the ceiling");
assert!(past.contains("outside `u128`'s range"), "{past}");
assert!(
past.contains("340282366920938463463374607431768211455"),
"{past}"
);
let under = refusal::<I128>(Value::String(String::from(
"-170141183460469231731687303715884105729",
)))
.expect("one past the floor");
assert!(
under.contains("-170141183460469231731687303715884105728"),
"{under}"
);
let empty = refusal::<U128>(Value::String(String::new())).expect("an empty string");
assert!(empty.contains("empty"), "{empty}");
let words = refusal::<U128>(Value::String(String::from("twelve"))).expect("not digits");
assert!(words.contains("DECIMAL TEXT"), "{words}");
assert!(refusal::<U128>(Value::String(String::from("-1"))).is_some());
}
#[test]
fn validity_and_parsing_are_one_question() {
for text in ["0", "340282366920938463463374607431768211455"] {
let value = Value::String(String::from(text));
assert!(U128::is_valid(&value), "{text}");
assert!(U128::parse(value).is_ok(), "{text}");
}
for text in [
"",
"-1",
"twelve",
"340282366920938463463374607431768211456",
] {
let value = Value::String(String::from(text));
assert!(!U128::is_valid(&value), "{text}");
assert!(U128::parse(value).is_err(), "{text}");
}
assert!(HexBytes::is_valid(&Value::String(String::from("89504e47"))));
assert!(!HexBytes::is_valid(&Value::String(String::from("89504e4"))));
}
#[test]
fn a_blob_round_trips_through_lowercase_hex() {
let png = vec![0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
let carrier = HexBytes::from(png.clone());
assert_eq!(rendered(carrier.clone()), "89504e470d0a1a0a");
assert_eq!(carrier.to_string(), "89504e470d0a1a0a");
assert_eq!(
HexBytes::parse(Value::String(String::from("89504e470d0a1a0a")))
.expect("its own rendering parses"),
carrier
);
for text in [
"89504E470D0A1A0A",
"0x89504e470d0a1a0a",
"0X89504E470D0A1A0A",
] {
let parsed = HexBytes::parse(Value::String(String::from(text))).expect(text);
assert_eq!(parsed.get(), &png, "{text}");
assert_eq!(rendered(parsed), "89504e470d0a1a0a", "{text}");
}
let empty = HexBytes::parse(Value::String(String::new())).expect("the empty blob");
assert!(empty.get().is_empty());
assert_eq!(rendered(empty), "");
}
#[test]
fn half_a_byte_is_not_a_byte_string() {
for text in ["89504e4", "89504e4g", "0x8", "not hex"] {
let refused = refusal::<HexBytes>(Value::String(String::from(text))).expect(text);
assert!(refused.contains("EVEN number of hex digits"), "{refused}");
}
assert!(refusal::<HexBytes>(Value::Number(7.into())).is_some());
}
#[test]
fn a_carrier_converts_both_ways() {
assert_eq!(u128::from(U128::from(u128::MAX)), u128::MAX);
assert_eq!(i128::from(I128::from(i128::MIN)), i128::MIN);
assert_eq!(
Vec::<u8>::from(HexBytes::from(vec![1, 2, 3])),
vec![1, 2, 3]
);
assert_eq!(*U128::from(7).get(), 7);
assert_eq!(U128::from(7).into_inner(), 7);
}
#[test]
fn an_address_round_trips_through_its_canonical_text() {
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
use super::{
NetIpAddr, NetIpv4Addr, NetIpv6Addr, NetSocketAddr, NetSocketAddrV4, NetSocketAddrV6,
};
macro_rules! round_trips {
($carrier:ident($value:expr) => $text:literal) => {{
let carrier = $carrier::from($value);
assert_eq!(rendered(carrier.clone()), $text);
assert_eq!(
$carrier::parse(Value::String(String::from($text))).expect("its own rendering parses"),
carrier,
$text
);
}};
}
round_trips!(NetIpv4Addr(Ipv4Addr::new(192, 0, 2, 1)) => "192.0.2.1");
round_trips!(NetIpv4Addr(Ipv4Addr::UNSPECIFIED) => "0.0.0.0");
round_trips!(NetIpv4Addr(Ipv4Addr::BROADCAST) => "255.255.255.255");
round_trips!(NetIpv6Addr(Ipv6Addr::LOCALHOST) => "::1");
round_trips!(NetIpv6Addr(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)) => "2001:db8::1");
round_trips!(NetIpAddr(IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1))) => "192.0.2.1");
round_trips!(NetIpAddr(IpAddr::V6(Ipv6Addr::LOCALHOST)) => "::1");
round_trips!(NetSocketAddrV4(SocketAddrV4::new(Ipv4Addr::new(192, 0, 2, 1), 443)) => "192.0.2.1:443");
round_trips!(NetSocketAddrV6(SocketAddrV6::new(Ipv6Addr::LOCALHOST, 443, 0, 0)) => "[::1]:443");
round_trips!(NetSocketAddr(SocketAddr::from(([192, 0, 2, 1], 443))) => "192.0.2.1:443");
round_trips!(NetSocketAddr(SocketAddr::from((Ipv6Addr::LOCALHOST, 443))) => "[::1]:443");
}
#[test]
fn an_ipv6_address_comes_back_in_exactly_one_spelling() {
use super::NetIpv6Addr;
for text in [
"2001:0DB8:0000:0000:0000:0000:0000:0001",
"2001:db8:0:0:0:0:0:1",
"2001:db8::0:1",
"2001:DB8::1",
] {
let parsed = NetIpv6Addr::parse(Value::String(String::from(text))).expect(text);
assert_eq!(rendered(parsed), "2001:db8::1", "{text}");
}
let mapped =
NetIpv6Addr::parse(Value::String(String::from("::ffff:c000:201"))).expect("a mapped address");
assert_eq!(rendered(mapped), "::ffff:192.0.2.1");
}
#[test]
fn a_malformed_address_is_refused_by_name() {
use super::{NetIpv4Addr, NetIpv6Addr, NetSocketAddr};
let refused = refusal::<NetIpv4Addr>(Value::String(String::from("01.2.3.4")))
.expect("a leading zero is not an address");
assert!(refused.contains("`Ipv4Addr`"), "{refused}");
assert!(refused.contains("DOTTED QUAD"), "{refused}");
assert!(
refused.contains("REFUSED and never guessed at"),
"{refused}"
);
for text in ["192.0.2.256", "192.0.2", "192.0.2.1 ", "", "::1"] {
assert!(
refusal::<NetIpv4Addr>(Value::String(String::from(text))).is_some(),
"{text}"
);
}
for text in ["2001:db8::1::2", "gggg::1", "192.0.2.1"] {
assert!(
refusal::<NetIpv6Addr>(Value::String(String::from(text))).is_some(),
"{text}"
);
}
let portless = refusal::<NetSocketAddr>(Value::String(String::from("192.0.2.1")))
.expect("an address with no port is not a socket address");
assert!(portless.contains("`SocketAddr`"), "{portless}");
assert!(refusal::<NetIpv4Addr>(Value::Number(7.into())).is_some());
assert!(!NetIpv4Addr::is_valid(&Value::Number(7.into())));
}
#[test]
fn address_validity_and_parsing_are_one_question() {
use super::{NetIpAddr, NetIpv4Addr};
for text in ["192.0.2.1", "0.0.0.0"] {
let value = Value::String(String::from(text));
assert!(NetIpv4Addr::is_valid(&value), "{text}");
assert!(NetIpv4Addr::parse(value).is_ok(), "{text}");
}
for text in ["01.2.3.4", "", "::1", "192.0.2.1:443"] {
let value = Value::String(String::from(text));
assert!(!NetIpv4Addr::is_valid(&value), "{text}");
assert!(NetIpv4Addr::parse(value).is_err(), "{text}");
}
for text in ["192.0.2.1", "2001:db8::1"] {
let value = Value::String(String::from(text));
assert!(NetIpAddr::is_valid(&value), "{text}");
assert!(NetIpAddr::parse(value).is_ok(), "{text}");
}
}
#[cfg(feature = "regex")]
#[test]
fn a_pattern_comes_back_exactly_as_it_was_written() {
use super::RegexPattern;
for pattern in [
"^[a-z]+(?:-[0-9]+)?$",
"(?i)README\\.md",
"(?x) a b ",
"\\p{Greek}+",
"",
] {
let parsed = RegexPattern::parse(Value::String(String::from(pattern)))
.unwrap_or_else(|_| panic!("`{pattern}` compiles"));
assert_eq!(
rendered(parsed),
pattern,
"`{pattern}` is returned verbatim"
);
}
}
#[cfg(feature = "regex")]
#[test]
fn a_pattern_that_does_not_compile_is_refused_with_the_engine_s_own_sentence() {
use super::RegexPattern;
let refused = refusal::<RegexPattern>(Value::String(String::from("a(b")))
.expect("an unclosed group is not a pattern");
assert!(
refused.contains("is not `Regex` text"),
"the refusal names the scalar: {refused}"
);
assert!(
refused.contains("COMPILED on the way in"),
"the refusal says what the crossing does: {refused}"
);
assert!(
refused.contains("unclosed group"),
"the refusal carries the engine's own diagnosis: {refused}"
);
let unsupported = refusal::<RegexPattern>(Value::String(String::from(r"(a)\1")))
.expect("this engine has no backreference");
assert!(
unsupported.contains("backreferences"),
"the dialect's own refusal reaches the client: {unsupported}"
);
let wrong = refusal::<RegexPattern>(Value::Number(7.into())).expect("a number is not a pattern");
assert!(
wrong.contains("Expected input type \"Regex\""),
"a number is refused as the wrong type: {wrong}"
);
}
#[cfg(feature = "regex")]
#[test]
fn validating_a_pattern_is_compiling_it() {
use super::RegexPattern;
for (pattern, valid) in [("^ok$", true), ("a(b", false), (r"(a)\1", false)] {
let value = Value::String(String::from(pattern));
assert_eq!(RegexPattern::is_valid(&value), valid, "{pattern}");
assert_eq!(
RegexPattern::parse(value).is_ok(),
valid,
"{pattern} parses exactly when it validates"
);
}
}
#[cfg(feature = "regex")]
#[test]
fn a_pattern_carrier_converts_both_ways() {
use super::RegexPattern;
let compiled = regex::Regex::new("^a+$").expect("a pattern");
let carried = RegexPattern::from(compiled);
assert_eq!(carried.get().as_str(), "^a+$");
assert_eq!(
regex::Regex::from(carried.clone()).as_str(),
"^a+$",
"and back out again"
);
assert_eq!(carried.into_inner().as_str(), "^a+$");
}