pub const MAX_STAGED_ITEMS_V3: u64 = 65_536;
use crate::diagnostic::{Diagnostic, DiagnosticCategory, DiagnosticDetailValue};
pub const MAX_STAGED_PLANS_V3: u32 = 64;
pub const DEFAULT_STAGED_WRITE_STATEMENTS_V3: u32 = 256;
pub const DEFAULT_STAGED_READ_STATEMENTS_V3: u32 = MAX_STAGED_PLANS_V3 * 3;
pub const MAX_STAGED_STATEMENTS_V3: u32 = 4_096;
pub const MAX_CANONICAL_BYTES: usize = 16 * 1024 * 1024;
pub const MAX_REMOTE_ENVELOPE_BYTES: usize = 32 * 1024 * 1024;
pub const MAX_CANONICAL_DEPTH: usize = 64;
pub const MAX_CANONICAL_COLLECTION_LEN: usize = 65_536;
pub const MAX_CANONICAL_STRING_BYTES: usize = 1024 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CodecLimits {
pub max_bytes: usize,
pub max_depth: usize,
pub max_collection_len: usize,
pub max_string_bytes: usize,
}
impl CodecLimits {
pub const CANONICAL: Self = Self {
max_bytes: MAX_CANONICAL_BYTES,
max_depth: MAX_CANONICAL_DEPTH,
max_collection_len: MAX_CANONICAL_COLLECTION_LEN,
max_string_bytes: MAX_CANONICAL_STRING_BYTES,
};
}
impl Default for CodecLimits {
fn default() -> Self {
Self::CANONICAL
}
}
pub const CANONICAL_CODEC_LIMITS: CodecLimits = CodecLimits::CANONICAL;
pub const REMOTE_ENVELOPE_CODEC_LIMITS: CodecLimits = CodecLimits {
max_bytes: MAX_REMOTE_ENVELOPE_BYTES,
max_depth: MAX_CANONICAL_DEPTH,
max_collection_len: MAX_CANONICAL_COLLECTION_LEN,
max_string_bytes: MAX_CANONICAL_STRING_BYTES,
};
pub const STAGED_REMOTE_CODEC_LIMITS_V3: CodecLimits = CodecLimits {
max_string_bytes: MAX_REMOTE_ENVELOPE_BYTES,
..REMOTE_ENVELOPE_CODEC_LIMITS
};
pub const REMOTE_REQUEST_CODEC_LIMITS: CodecLimits = CodecLimits {
max_bytes: MAX_REMOTE_ENVELOPE_BYTES,
max_depth: MAX_CANONICAL_DEPTH + 1,
max_collection_len: MAX_CANONICAL_COLLECTION_LEN,
max_string_bytes: MAX_CANONICAL_STRING_BYTES,
};
pub const MAX_SELECTED_SLOTS: usize = 16;
pub const MAX_BINDINGS: usize = 256;
pub const MAX_PREDICATE_NODES: usize = 4_096;
pub const MAX_PREDICATE_DEPTH: usize = 64;
pub const MAX_BOOLEAN_TERMS: usize = 256;
pub const MAX_ALLOWED_CROSS_JOINS: usize = 1_024;
pub const MAX_ORDER_TERMS: usize = 64;
pub const MAX_COLLECTION_ORDER_TERMS: usize = 64;
pub const MAX_INPUT_ROWS: usize = 4_096;
pub const MAX_INPUT_BYTES: usize = 4 * 1024 * 1024;
pub const MAX_QUERY_INVOCATION_BYTES: usize = MAX_INPUT_BYTES + 234;
pub const MAX_OUTPUT_NAME_BYTES: usize = 128;
pub const MAX_SEMANTIC_ID_BYTES: usize = 512;
pub const MAX_DIAGNOSTIC_BYTES: usize = 65_536;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StructuralLimits {
pub selected_slots: usize,
pub bindings: usize,
pub predicate_nodes: usize,
pub predicate_depth: usize,
pub boolean_terms: usize,
pub allowed_cross_joins: usize,
pub order_terms: usize,
pub collection_order_terms: usize,
pub input_rows: usize,
pub input_bytes: usize,
pub output_name_bytes: usize,
pub semantic_id_bytes: usize,
pub diagnostic_bytes: usize,
}
impl StructuralLimits {
pub const CANONICAL: Self = Self {
selected_slots: MAX_SELECTED_SLOTS,
bindings: MAX_BINDINGS,
predicate_nodes: MAX_PREDICATE_NODES,
predicate_depth: MAX_PREDICATE_DEPTH,
boolean_terms: MAX_BOOLEAN_TERMS,
allowed_cross_joins: MAX_ALLOWED_CROSS_JOINS,
order_terms: MAX_ORDER_TERMS,
collection_order_terms: MAX_COLLECTION_ORDER_TERMS,
input_rows: MAX_INPUT_ROWS,
input_bytes: MAX_INPUT_BYTES,
output_name_bytes: MAX_OUTPUT_NAME_BYTES,
semantic_id_bytes: MAX_SEMANTIC_ID_BYTES,
diagnostic_bytes: MAX_DIAGNOSTIC_BYTES,
};
pub const fn allows_selected_slots(self, actual: usize) -> bool {
actual <= self.selected_slots
}
pub const fn allows_bindings(self, actual: usize) -> bool {
actual <= self.bindings
}
pub const fn allows_input_rows(self, actual: usize) -> bool {
actual <= self.input_rows
}
pub const fn allows_input_bytes(self, actual: usize) -> bool {
actual <= self.input_bytes
}
pub const fn allows_order_terms(self, actual: usize) -> bool {
actual <= self.order_terms
}
pub const fn allows_predicate_nodes(self, actual: usize) -> bool {
actual <= self.predicate_nodes
}
pub const fn allows_predicate_depth(self, actual: usize) -> bool {
actual <= self.predicate_depth
}
pub const fn allows_diagnostic_bytes(self, actual: usize) -> bool {
actual <= self.diagnostic_bytes
}
}
impl StructuralLimits {
#[must_use]
pub fn annotate(self, diagnostic: Diagnostic) -> Diagnostic {
QueryLimits {
structural: self,
..QueryLimits::CANONICAL
}
.annotate(diagnostic)
}
}
impl Default for StructuralLimits {
fn default() -> Self {
Self::CANONICAL
}
}
pub const CANONICAL_STRUCTURAL_LIMITS: StructuralLimits = StructuralLimits::CANONICAL;
pub const MAX_SUPPORTED_CANONICAL_DEPTH: usize = 126;
pub const MAX_SUPPORTED_SELECTED_SLOTS: usize = MAX_SELECTED_SLOTS;
pub const MAX_SUPPORTED_BINDINGS: usize = 1 << 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct QueryLimits {
pub codec: CodecLimits,
pub structural: StructuralLimits,
pub remote_request_bytes: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum QueryLimitsError {
Unknown {
name: String,
},
OutOfRange {
limit: &'static str,
value: u64,
minimum: u64,
maximum: u64,
},
}
impl QueryLimitsError {
#[must_use]
pub fn limit(&self) -> &str {
match self {
Self::Unknown { name } => name,
Self::OutOfRange { limit, .. } => limit,
}
}
}
impl std::fmt::Display for QueryLimitsError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Unknown { name } => write!(formatter, "`{name}` is not a known query limit"),
Self::OutOfRange {
limit,
value,
minimum,
maximum,
} => write!(
formatter,
"query limit `{limit}` is {value}; it must be between {minimum} and {maximum}"
),
}
}
}
impl std::error::Error for QueryLimitsError {}
macro_rules! query_limit_fields {
($(($name:literal, $($path:ident).+, $maximum:expr)),+ $(,)?) => {
impl QueryLimits {
pub const FIELDS: &'static [&'static str] = &[$($name),+];
#[must_use]
pub fn get(&self, name: &str) -> Option<usize> {
match name {
$($name => Some(self.$($path).+),)+
_ => None,
}
}
pub fn set(&mut self, name: &str, value: usize) -> bool {
match name {
$($name => self.$($path).+ = value,)+
_ => return false,
}
true
}
#[must_use]
pub fn supported_maximum(name: &str) -> Option<usize> {
match name {
$($name => Some($maximum),)+
_ => None,
}
}
}
};
}
query_limit_fields![
("canonical_bytes", codec.max_bytes, usize::MAX),
(
"canonical_depth",
codec.max_depth,
MAX_SUPPORTED_CANONICAL_DEPTH
),
(
"canonical_collection_len",
codec.max_collection_len,
usize::MAX
),
("canonical_string_bytes", codec.max_string_bytes, usize::MAX),
(
"selected_slots",
structural.selected_slots,
MAX_SUPPORTED_SELECTED_SLOTS
),
("bindings", structural.bindings, MAX_SUPPORTED_BINDINGS),
("predicate_nodes", structural.predicate_nodes, usize::MAX),
(
"predicate_depth",
structural.predicate_depth,
MAX_SUPPORTED_CANONICAL_DEPTH
),
("boolean_terms", structural.boolean_terms, usize::MAX),
(
"allowed_cross_joins",
structural.allowed_cross_joins,
usize::MAX
),
("order_terms", structural.order_terms, usize::MAX),
(
"collection_order_terms",
structural.collection_order_terms,
usize::MAX
),
("input_rows", structural.input_rows, usize::MAX),
("input_bytes", structural.input_bytes, usize::MAX),
(
"output_name_bytes",
structural.output_name_bytes,
usize::MAX
),
(
"semantic_id_bytes",
structural.semantic_id_bytes,
usize::MAX
),
("diagnostic_bytes", structural.diagnostic_bytes, usize::MAX),
("remote_request_bytes", remote_request_bytes, usize::MAX),
];
impl QueryLimits {
pub const CANONICAL: Self = Self {
codec: CodecLimits::CANONICAL,
structural: StructuralLimits::CANONICAL,
remote_request_bytes: MAX_REMOTE_ENVELOPE_BYTES,
};
pub fn validate(self) -> Result<Self, QueryLimitsError> {
for name in Self::FIELDS {
let value = self.get(name).expect("listed limit exists");
let maximum = Self::supported_maximum(name).expect("listed limit exists");
if value == 0 || value > maximum {
return Err(QueryLimitsError::OutOfRange {
limit: name,
value: u64::try_from(value).unwrap_or(u64::MAX),
minimum: 1,
maximum: u64::try_from(maximum).unwrap_or(u64::MAX),
});
}
}
Ok(self)
}
pub fn from_overrides<'name>(
overrides: impl IntoIterator<Item = (&'name str, u64)>,
) -> Result<Self, QueryLimitsError> {
let mut limits = Self::CANONICAL;
for (name, value) in overrides {
let Some(listed) = Self::FIELDS.iter().find(|listed| **listed == name) else {
return Err(QueryLimitsError::Unknown {
name: name.to_owned(),
});
};
let Ok(value) = usize::try_from(value) else {
return Err(QueryLimitsError::OutOfRange {
limit: listed,
value,
minimum: 1,
maximum: u64::try_from(
Self::supported_maximum(listed).expect("listed limit exists"),
)
.unwrap_or(u64::MAX),
});
};
limits.set(listed, value);
}
limits.validate()
}
#[must_use]
pub fn min(mut self, other: Self) -> Self {
for name in Self::FIELDS {
let stricter = self
.get(name)
.expect("listed limit exists")
.min(other.get(name).expect("listed limit exists"));
self.set(name, stricter);
}
self
}
#[must_use]
pub const fn remote_request_codec(self) -> CodecLimits {
CodecLimits {
max_bytes: self.remote_request_bytes,
max_depth: self.codec.max_depth + 1,
..self.codec
}
}
#[must_use]
pub const fn invocation_bytes(self) -> usize {
self.structural
.input_bytes
.saturating_add(MAX_QUERY_INVOCATION_BYTES - MAX_INPUT_BYTES)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AnswerLimitField {
pub name: &'static str,
pub direct_default: u64,
pub proxy_default: u64,
pub maximum: u64,
}
pub const ANSWER_LIMIT_FIELDS: [AnswerLimitField; 8] = [
AnswerLimitField {
name: "timeout_milliseconds",
direct_default: 30_000,
proxy_default: 30_000,
maximum: 24 * 60 * 60 * 1000,
},
AnswerLimitField {
name: "items",
direct_default: 100_000,
proxy_default: MAX_CANONICAL_COLLECTION_LEN as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "bytes",
direct_default: 64 * 1024 * 1024,
proxy_default: MAX_REMOTE_ENVELOPE_BYTES as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "graph_nodes",
direct_default: 1_000_000,
proxy_default: MAX_CANONICAL_COLLECTION_LEN as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "attribute_values",
direct_default: 4_000_000,
proxy_default: MAX_CANONICAL_COLLECTION_LEN as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "collection_members",
direct_default: 1_000_000,
proxy_default: MAX_CANONICAL_COLLECTION_LEN as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "role_players",
direct_default: 1_000_000,
proxy_default: MAX_CANONICAL_COLLECTION_LEN as u64,
maximum: u64::MAX,
},
AnswerLimitField {
name: "statements",
direct_default: 3,
proxy_default: 3,
maximum: 3,
},
];
#[must_use]
pub fn answer_limit_field(name: &str) -> Option<AnswerLimitField> {
ANSWER_LIMIT_FIELDS
.iter()
.copied()
.find(|field| field.name == name)
}
pub const LIMIT_SOURCE_DEFAULT: &str = "default";
pub const LIMIT_SOURCE_CONFIGURED: &str = "configured";
pub const LIMIT_SOURCE_ADVERTISED: &str = "advertised";
const LIMIT_BY_DIAGNOSTIC_CODE: &[(&str, &str)] = &[
("canonical_json_too_deep", "canonical_depth"),
("canonical_json_too_large", "canonical_bytes"),
("canonical_collection_too_large", "canonical_collection_len"),
("canonical_string_too_large", "canonical_string_bytes"),
("query_builder_authored_binding_limit", "bindings"),
("query_invocation_input_byte_limit", "input_bytes"),
("query_invocation_row_limit", "input_rows"),
("query_plan_binding_limit", "bindings"),
("query_plan_disjunction_term_limit", "boolean_terms"),
("query_plan_function_argument_limit", "boolean_terms"),
("query_plan_input_limit", "bindings"),
("query_plan_local_function_limit", "bindings"),
("query_plan_name_limit", "output_name_bytes"),
("query_plan_negation_term_limit", "boolean_terms"),
("query_plan_output_limit", "selected_slots"),
("query_plan_pattern_depth_limit", "predicate_depth"),
("query_plan_pattern_limit", "boolean_terms"),
("query_plan_pattern_node_limit", "predicate_nodes"),
("query_plan_reachable_depth", "predicate_depth"),
("query_plan_reachable_expansion_limit", "predicate_nodes"),
("query_plan_reduce_term_limit", "boolean_terms"),
("query_plan_role_player_limit", "boolean_terms"),
("query_plan_sort_term_limit", "order_terms"),
("query_plan_try_term_limit", "boolean_terms"),
("query_plan_v2_boolean_term_limit", "boolean_terms"),
("query_plan_v2_compatibility_value_limit", "canonical_bytes"),
("query_plan_v2_cross_join_limit", "allowed_cross_joins"),
("query_plan_v2_order_limit", "order_terms"),
("query_plan_v2_output_limit", "selected_slots"),
("query_plan_v2_pattern_depth_limit", "predicate_depth"),
("query_plan_v2_pattern_node_limit", "predicate_nodes"),
("query_plan_v2_reachable_depth", "predicate_depth"),
("query_plan_v2_reachable_expansion_limit", "predicate_nodes"),
("query_plan_v2_reducer_limit", "selected_slots"),
("query_plan_v2_reduction_group_limit", "selected_slots"),
("query_remote_v2_envelope_too_large", "remote_request_bytes"),
("query_v2_adapter_literal_byte_limit", "canonical_bytes"),
("query_v2_lowered_typeql_byte_limit", "canonical_bytes"),
("query_v2_reachable_expansion_limit", "predicate_nodes"),
];
impl QueryLimits {
#[must_use]
pub fn source_of(&self, name: &str) -> &'static str {
if self.get(name) == Self::CANONICAL.get(name) {
LIMIT_SOURCE_DEFAULT
} else {
LIMIT_SOURCE_CONFIGURED
}
}
#[must_use]
pub fn annotate(self, diagnostic: Diagnostic) -> Diagnostic {
let Some((_, limit)) = LIMIT_BY_DIAGNOSTIC_CODE
.iter()
.find(|(code, _)| *code == diagnostic.code().as_str())
else {
return diagnostic;
};
self.annotate_limit(diagnostic, limit)
}
#[must_use]
pub fn annotate_refusal(diagnostic: Diagnostic, maximum: usize) -> Diagnostic {
let Some((_, limit)) = LIMIT_BY_DIAGNOSTIC_CODE
.iter()
.find(|(code, _)| *code == diagnostic.code().as_str())
else {
return diagnostic;
};
let mut limits = Self::CANONICAL;
limits.set(limit, maximum);
limits.annotate_limit(diagnostic, limit)
}
#[must_use]
pub fn annotate_negotiated(self, configured: Self, diagnostic: Diagnostic) -> Diagnostic {
self.mark_advertised(configured, self.annotate(diagnostic))
}
#[must_use]
pub fn mark_advertised(self, configured: Self, diagnostic: Diagnostic) -> Diagnostic {
let Some(DiagnosticDetailValue::Text(limit)) = diagnostic.details().get("limit") else {
return diagnostic;
};
if self.get(limit) < configured.get(limit) {
diagnostic.with_detail("source", LIMIT_SOURCE_ADVERTISED)
} else {
diagnostic
}
}
#[must_use]
pub fn annotate_limit(self, diagnostic: Diagnostic, limit: &'static str) -> Diagnostic {
if diagnostic.category() != DiagnosticCategory::ResourceLimit
|| diagnostic.details().contains_key("limit")
{
return diagnostic;
}
let Some(maximum) = self.get(limit) else {
return diagnostic;
};
diagnostic
.with_detail("limit", limit)
.with_detail("maximum", i64::try_from(maximum).unwrap_or(i64::MAX))
.with_detail("source", self.source_of(limit))
}
}
impl Default for QueryLimits {
fn default() -> Self {
Self::CANONICAL
}
}
#[cfg(test)]
mod query_limits_tests {
use super::*;
use crate::codec::{from_canonical_json_with_limits, to_canonical_json_with_limits};
fn nested(depth: usize) -> serde_json::Value {
let mut value = serde_json::Value::Array(Vec::new());
for _ in 1..depth {
value = serde_json::Value::Array(vec![value]);
}
value
}
#[test]
fn canonical_limits_are_the_released_constants_and_validate() {
let limits = QueryLimits::CANONICAL.validate().expect("canonical limits");
assert_eq!(limits.remote_request_codec(), REMOTE_REQUEST_CODEC_LIMITS);
assert_eq!(limits.invocation_bytes(), MAX_QUERY_INVOCATION_BYTES);
assert_eq!(QueryLimits::default(), limits);
}
#[test]
fn every_limit_is_named_once_and_round_trips() {
let mut limits = QueryLimits::CANONICAL;
let mut seen = std::collections::BTreeSet::new();
for (index, name) in QueryLimits::FIELDS.iter().enumerate() {
assert!(seen.insert(*name), "duplicate limit name {name}");
assert!(limits.set(name, index + 7));
}
for (index, name) in QueryLimits::FIELDS.iter().enumerate() {
assert_eq!(limits.get(name), Some(index + 7));
}
assert!(!limits.set("unknown", 1));
assert_eq!(limits.get("unknown"), None);
let codec = limits.codec;
let structural = limits.structural;
assert_eq!(QueryLimits::FIELDS.len(), 18);
assert_ne!(codec.max_bytes, CodecLimits::CANONICAL.max_bytes);
assert_ne!(structural.diagnostic_bytes, MAX_DIAGNOSTIC_BYTES);
}
#[test]
fn validation_refuses_zero_and_unsupported_values_by_name() {
let mut zero = QueryLimits::CANONICAL;
zero.structural.boolean_terms = 0;
assert_eq!(zero.validate().unwrap_err().limit(), "boolean_terms");
let mut deep = QueryLimits::CANONICAL;
deep.codec.max_depth = MAX_SUPPORTED_CANONICAL_DEPTH + 1;
let error = deep.validate().unwrap_err();
assert_eq!(error.limit(), "canonical_depth");
assert!(error.to_string().contains("between 1 and 126"));
let mut wide = QueryLimits::CANONICAL;
wide.structural.bindings = MAX_SUPPORTED_BINDINGS + 1;
assert_eq!(wide.validate().unwrap_err().limit(), "bindings");
let mut slots = QueryLimits::CANONICAL;
slots.structural.selected_slots = MAX_SUPPORTED_SELECTED_SLOTS + 1;
assert_eq!(slots.validate().unwrap_err().limit(), "selected_slots");
let mut raised = QueryLimits::CANONICAL;
raised.codec.max_bytes = 64 * 1024 * 1024;
raised.remote_request_bytes = 128 * 1024 * 1024;
raised.codec.max_depth = MAX_SUPPORTED_CANONICAL_DEPTH;
raised
.validate()
.expect("limits above canonical are admissible");
}
#[test]
fn every_attributed_code_names_a_real_limit() {
for (code, limit) in LIMIT_BY_DIAGNOSTIC_CODE {
assert!(
QueryLimits::CANONICAL.get(limit).is_some(),
"{code} is attributed to unknown limit {limit}"
);
}
}
#[test]
fn annotation_names_the_limit_its_value_and_its_source() {
use crate::diagnostic::{DiagnosticCode, DiagnosticDetailValue};
let raise = |code: &str, category| {
Diagnostic::new(
category,
DiagnosticCode::new(code).expect("code"),
"refused",
)
};
let mut limits = QueryLimits::CANONICAL;
limits.structural.boolean_terms = 8;
let configured = limits.annotate(raise(
"query_plan_v2_boolean_term_limit",
DiagnosticCategory::ResourceLimit,
));
assert_eq!(
configured.details().get("limit"),
Some(&DiagnosticDetailValue::Text("boolean_terms".into()))
);
assert_eq!(
configured.details().get("maximum"),
Some(&DiagnosticDetailValue::Long(8))
);
assert_eq!(
configured.details().get("source"),
Some(&DiagnosticDetailValue::Text("configured".into()))
);
let default = limits.annotate(raise(
"canonical_json_too_deep",
DiagnosticCategory::ResourceLimit,
));
assert_eq!(
default.details().get("source"),
Some(&DiagnosticDetailValue::Text("default".into()))
);
assert_eq!(
default.details().get("maximum"),
Some(&DiagnosticDetailValue::Long(64))
);
let invalid = limits.annotate(raise(
"canonical_json_too_deep",
DiagnosticCategory::InvalidContract,
));
assert!(invalid.details().is_empty());
let unknown = limits.annotate(raise("some_other_limit", DiagnosticCategory::ResourceLimit));
assert!(unknown.details().is_empty());
}
#[test]
fn named_overrides_build_validated_limits() {
let limits = QueryLimits::from_overrides([("canonical_bytes", 64 << 20), ("bindings", 8)])
.expect("named overrides");
assert_eq!(limits.codec.max_bytes, 64 << 20);
assert_eq!(limits.structural.bindings, 8);
assert_eq!(limits.structural.boolean_terms, MAX_BOOLEAN_TERMS);
assert_eq!(
QueryLimits::from_overrides([]).expect("no overrides"),
QueryLimits::CANONICAL
);
assert_eq!(
QueryLimits::from_overrides([("made_up", 1)]).unwrap_err(),
QueryLimitsError::Unknown {
name: "made_up".into()
}
);
assert_eq!(
QueryLimits::from_overrides([("canonical_depth", 1_000)])
.unwrap_err()
.limit(),
"canonical_depth"
);
}
#[test]
fn a_refusal_is_annotated_from_the_ceiling_its_stage_enforced() {
use crate::diagnostic::{DiagnosticCode, DiagnosticDetailValue};
let refusal = || {
Diagnostic::new(
DiagnosticCategory::ResourceLimit,
DiagnosticCode::new("query_plan_sort_term_limit").expect("code"),
"refused",
)
};
let default = QueryLimits::annotate_refusal(refusal(), MAX_ORDER_TERMS);
assert_eq!(
default.details().get("source"),
Some(&DiagnosticDetailValue::Text("default".into()))
);
let configured = QueryLimits::annotate_refusal(refusal(), 4);
assert_eq!(
configured.details().get("maximum"),
Some(&DiagnosticDetailValue::Long(4))
);
assert_eq!(
configured.details().get("source"),
Some(&DiagnosticDetailValue::Text("configured".into()))
);
}
#[test]
fn min_takes_the_stricter_value_of_each_limit() {
let mut left = QueryLimits::CANONICAL;
left.codec.max_depth = 100;
left.structural.bindings = 8;
let mut right = QueryLimits::CANONICAL;
right.structural.bindings = 512;
right.remote_request_bytes = 1024;
let merged = left.min(right);
assert_eq!(merged.codec.max_depth, 64);
assert_eq!(merged.structural.bindings, 8);
assert_eq!(merged.remote_request_bytes, 1024);
}
#[test]
fn the_supported_depth_is_what_the_parser_decodes_inside_a_request_frame() {
let mut limits = QueryLimits::CANONICAL;
limits.codec.max_depth = MAX_SUPPORTED_CANONICAL_DEPTH;
let request = limits
.validate()
.expect("supported depth")
.remote_request_codec();
let deepest = nested(MAX_SUPPORTED_CANONICAL_DEPTH + 1);
let bytes = to_canonical_json_with_limits(&deepest, request).expect("encodes");
from_canonical_json_with_limits::<serde_json::Value>(&bytes, request)
.expect("the deepest admissible request frame decodes");
let unbounded = CodecLimits {
max_depth: usize::MAX,
..request
};
let beyond = to_canonical_json_with_limits(&nested(128), unbounded).expect("encodes");
assert!(from_canonical_json_with_limits::<serde_json::Value>(&beyond, unbounded).is_err());
}
}