use alloc::{borrow::Cow, format, string::String, vec::Vec};
use core::fmt;
use jsonx_lib::{DuplicateKeys, Event, Number, Parser, RawValue, Reader};
use crate::{
error_object::ErrorObject,
id::Id,
limits::Limits,
raw::{Json, Raw},
};
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Request<'a> {
pub id: Id<'a>,
pub method: Cow<'a, str>,
pub params: Option<Raw<'a>>,
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Notification<'a> {
pub method: Cow<'a, str>,
pub params: Option<Raw<'a>>,
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Response<'a> {
pub id: Option<Id<'a>>,
pub result: Result<Raw<'a>, ErrorObject>,
}
impl<'a> Request<'a> {
#[must_use]
pub fn new(
id: impl Into<Id<'a>>,
method: impl Into<Cow<'a, str>>,
params: Option<Raw<'a>>,
) -> Self {
Self {
id: id.into(),
method: method.into(),
params,
}
}
}
impl<'a> Notification<'a> {
#[must_use]
pub fn new(method: impl Into<Cow<'a, str>>, params: Option<Raw<'a>>) -> Self {
Self {
method: method.into(),
params,
}
}
}
impl<'a> Response<'a> {
#[must_use]
pub const fn new(id: Option<Id<'a>>, result: Result<Raw<'a>, ErrorObject>) -> Self {
Self { id, result }
}
#[must_use]
pub fn ok(id: impl Into<Id<'a>>, result: Raw<'a>) -> Self {
Self {
id: Some(id.into()),
result: Ok(result),
}
}
#[must_use]
pub const fn err(id: Option<Id<'a>>, error: ErrorObject) -> Self {
Self {
id,
result: Err(error),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Message<'a> {
Request(Request<'a>),
Notification(Notification<'a>),
Response(Response<'a>),
}
impl<'a> Message<'a> {
#[must_use]
pub fn id(&self) -> Option<&Id<'a>> {
match self {
Message::Request(r) => Some(&r.id),
Message::Notification(_) => None,
Message::Response(r) => r.id.as_ref(),
}
}
#[must_use]
pub fn method(&self) -> Option<&str> {
match self {
Message::Request(r) => Some(&r.method),
Message::Notification(n) => Some(&n.method),
Message::Response(_) => None,
}
}
pub fn write(&self, out: &mut String) {
match self {
Message::Request(r) => {
let params = r.params.as_ref().map(|p| Json::Raw(p.reborrow()));
write_call(out, Some(&r.id), &r.method, params.as_ref());
}
Message::Notification(n) => {
let params = n.params.as_ref().map(|p| Json::Raw(p.reborrow()));
write_call(out, None, &n.method, params.as_ref());
}
Message::Response(r) => {
let result = match &r.result {
Ok(raw) => Ok(Json::Raw(raw.reborrow())),
Err(error) => Err(error),
};
write_response(out, r.id.as_ref(), result.as_ref().map_err(|e| *e), false);
}
}
}
#[must_use]
pub fn into_owned(self) -> Message<'static> {
match self {
Message::Request(r) => Message::Request(Request {
id: r.id.into_owned(),
method: Cow::Owned(r.method.into_owned()),
params: r.params.map(Raw::into_owned),
}),
Message::Notification(n) => Message::Notification(Notification {
method: Cow::Owned(n.method.into_owned()),
params: n.params.map(Raw::into_owned),
}),
Message::Response(r) => Message::Response(Response {
id: r.id.map(Id::into_owned),
result: r.result.map(Raw::into_owned),
}),
}
}
}
impl fmt::Display for Message<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut out = String::new();
self.write(&mut out);
f.write_str(&out)
}
}
pub fn write_batch(out: &mut String, messages: &[Message<'_>]) {
out.push('[');
for (i, message) in messages.iter().enumerate() {
if i > 0 {
out.push(',');
}
message.write(out);
}
out.push(']');
}
pub(crate) fn write_call(
out: &mut String,
id: Option<&Id<'_>>,
method: &str,
params: Option<&Json<'_>>,
) {
out.push_str("{\"jsonrpc\":\"2.0\",");
if let Some(id) = id {
out.push_str("\"id\":");
id.write(out);
out.push(',');
}
write_method_params(out, method, params);
}
#[cfg(feature = "std")]
pub(crate) fn write_numbered_call(
out: &mut String,
id: u64,
method: &str,
params: Option<&Json<'_>>,
) {
out.push_str("{\"jsonrpc\":\"2.0\",\"id\":");
crate::text::push_u64(out, id);
out.push(',');
write_method_params(out, method, params);
}
fn write_method_params(out: &mut String, method: &str, params: Option<&Json<'_>>) {
out.push_str("\"method\":");
jsonx_lib::write_string(out, method);
if let Some(params) = params {
out.push_str(",\"params\":");
params.write(out);
}
out.push('}');
}
pub(crate) fn write_response(
out: &mut String,
id: Option<&Id<'_>>,
result: Result<&Json<'_>, &ErrorObject>,
omit_null_id: bool,
) {
out.push_str("{\"jsonrpc\":\"2.0\"");
match id {
Some(id) => {
out.push_str(",\"id\":");
id.write(out);
}
None if omit_null_id => {}
None => out.push_str(",\"id\":null"),
}
match result {
Ok(value) => {
out.push_str(",\"result\":");
value.write(out);
}
Err(error) => {
out.push_str(",\"error\":");
error.write(out);
}
}
out.push('}');
}
#[derive(Clone, Debug, PartialEq)]
pub struct Invalid<'a> {
id: Option<Id<'a>>,
response: bool,
error: ErrorObject,
}
impl<'a> Invalid<'a> {
#[must_use]
pub fn id(&self) -> Option<&Id<'a>> {
self.id.as_ref()
}
#[must_use]
pub const fn is_response(&self) -> bool {
self.response
}
#[must_use]
pub const fn error(&self) -> &ErrorObject {
&self.error
}
#[must_use]
pub fn reply(&self) -> Option<Response<'a>> {
(!self.response).then(|| Response {
id: self.id.clone(),
result: Err(self.error.clone()),
})
}
#[must_use]
pub fn into_owned(self) -> Invalid<'static> {
Invalid {
id: self.id.map(Id::into_owned),
response: self.response,
error: self.error,
}
}
fn request(id: Option<Id<'a>>, error: ErrorObject) -> Self {
Self {
id,
response: false,
error,
}
}
}
pub type Entry<'a> = Result<Message<'a>, Invalid<'a>>;
#[derive(Clone, Debug, PartialEq)]
pub enum Incoming<'a> {
Single(Entry<'a>),
Batch(Vec<Entry<'a>>),
}
#[must_use]
pub fn decode<'a>(body: &'a [u8], limits: &Limits) -> Incoming<'a> {
let parser = envelope_parser(&limits.parser());
let mut reader = match parser.reader_bytes(body) {
Ok(reader) => reader,
Err(error) => return Incoming::Single(Err(unreadable(Fail::Json(error), None))),
};
let first = match reader.next_event() {
Ok(Some(event)) => event,
Ok(None) => return Incoming::Single(Err(unreadable(Fail::Shape, None))),
Err(error) => return Incoming::Single(Err(unreadable(Fail::Json(error), None))),
};
match first {
Event::StartObject => {
let mut fields = Fields::default();
let read = read_members(&mut reader, &mut fields)
.and_then(|()| reader.finish().map_err(Fail::Json));
match read {
Ok(()) => Incoming::Single(classify(fields, &parser, limits)),
Err(fail) => {
let salvaged = fields.salvage(limits);
Incoming::Single(Err(unreadable(fail, salvaged)))
}
}
}
Event::StartArray => decode_batch(reader, &parser, limits),
_ => match reader.finish() {
Ok(()) => Incoming::Single(Err(Invalid::request(
None,
ErrorObject::invalid_request("a message must be an object or an array"),
))),
Err(error) => Incoming::Single(Err(unreadable(Fail::Json(error), None))),
},
}
}
fn envelope_parser(parser: &Parser) -> Parser {
parser.duplicate_keys(DuplicateKeys::KeepAll)
}
fn decode_batch<'a>(mut reader: Reader<'a>, parser: &Parser, limits: &Limits) -> Incoming<'a> {
let max = limits.max_batch;
if max == 0 {
return Incoming::Single(Err(Invalid::request(
None,
ErrorObject::invalid_request("batches are not accepted"),
)));
}
let mut entries = Vec::new();
loop {
let event = match reader.next_event() {
Ok(Some(event)) => event,
Ok(None) => return Incoming::Single(Err(unreadable(Fail::Shape, None))),
Err(error) => return Incoming::Single(Err(unreadable(Fail::Json(error), None))),
};
if matches!(event, Event::EndArray) {
break;
}
if entries.len() >= max {
let message = format!("a batch may hold at most {max} messages");
return Incoming::Single(Err(Invalid::request(
None,
ErrorObject::invalid_request(message),
)));
}
let entry = match event {
Event::StartObject => {
let mut fields = Fields::default();
if let Err(fail) = read_members(&mut reader, &mut fields) {
return Incoming::Single(Err(unreadable(fail, None)));
}
classify(fields, parser, limits)
}
Event::StartArray => {
if let Err(fail) = skip_container(&mut reader) {
return Incoming::Single(Err(unreadable(fail, None)));
}
Err(not_a_message())
}
Event::EndObject | Event::Key(_) => {
return Incoming::Single(Err(unreadable(Fail::Shape, None)));
}
_ => Err(not_a_message()),
};
entries.push(entry);
}
if let Err(error) = reader.finish() {
return Incoming::Single(Err(unreadable(Fail::Json(error), None)));
}
if entries.is_empty() {
return Incoming::Single(Err(Invalid::request(
None,
ErrorObject::invalid_request("an empty batch is not a valid request"),
)));
}
Incoming::Batch(entries)
}
fn not_a_message() -> Invalid<'static> {
Invalid::request(
None,
ErrorObject::invalid_request("a batch element must be a message object"),
)
}
fn skip_container(reader: &mut Reader<'_>) -> Result<(), Fail> {
let mut depth = 1usize;
while depth > 0 {
match reader.next_event().map_err(Fail::Json)? {
Some(Event::StartArray | Event::StartObject) => depth += 1,
Some(Event::EndArray | Event::EndObject) => depth -= 1,
Some(_) => {}
None => return Err(Fail::Shape),
}
}
Ok(())
}
enum Fail {
Json(jsonx_lib::Error),
Shape,
}
fn unreadable(fail: Fail, salvaged: Option<Id<'_>>) -> Invalid<'_> {
match fail {
Fail::Json(error) if error.kind().is_budget() => Invalid::request(
salvaged,
ErrorObject::invalid_request(format!("the message exceeds a limit: {error}")),
),
Fail::Json(error) => Invalid::request(
None,
ErrorObject::parse_error(format!("invalid JSON: {error}")),
),
Fail::Shape => Invalid::request(None, ErrorObject::parse_error("invalid JSON")),
}
}
#[derive(Default)]
struct Fields<'a> {
jsonrpc: Option<&'a str>,
id: Option<&'a str>,
method: Option<&'a str>,
params: Option<RawValue<'a>>,
result: Option<RawValue<'a>>,
error: Option<&'a str>,
duplicate: Option<&'static str>,
id_repeated: bool,
}
impl<'a> Fields<'a> {
fn salvage(&self, limits: &Limits) -> Option<Id<'a>> {
if self.method.is_none() || self.id_repeated || self.id_too_long(limits) {
return None;
}
self.id
.map(read_id)
.and_then(|id| id.into_request_id(limits.lenient_ids))
}
fn id_too_long(&self, limits: &Limits) -> bool {
self.id.is_some_and(|raw| raw.len() > limits.max_id_bytes)
}
}
fn read_members<'a>(reader: &mut Reader<'a>, fields: &mut Fields<'a>) -> Result<(), Fail> {
loop {
let key = match reader.next_event().map_err(Fail::Json)? {
Some(Event::Key(key)) => key,
Some(Event::EndObject) => return Ok(()),
_ => return Err(Fail::Shape),
};
if matches!(&*key, "params" | "result") {
let value = reader
.read_raw_value()
.map_err(Fail::Json)?
.ok_or(Fail::Shape)?;
let (slot, name) = if *key == *"params" {
(&mut fields.params, "params")
} else {
(&mut fields.result, "result")
};
if slot.is_some() {
let _first = fields.duplicate.get_or_insert(name);
} else {
*slot = Some(value);
}
continue;
}
let raw = reader.read_raw().map_err(Fail::Json)?.ok_or(Fail::Shape)?;
let (slot, name) = match &*key {
"jsonrpc" => (&mut fields.jsonrpc, "jsonrpc"),
"id" => (&mut fields.id, "id"),
"method" => (&mut fields.method, "method"),
"error" => (&mut fields.error, "error"),
_ => continue,
};
if slot.is_some() {
let _first = fields.duplicate.get_or_insert(name);
fields.id_repeated |= name == "id";
} else {
*slot = Some(raw);
}
}
}
enum IdValue<'a> {
Valid(Id<'a>),
Null,
OtherNumber(&'a str),
Invalid,
}
impl<'a> IdValue<'a> {
fn into_request_id(self, lenient: bool) -> Option<Id<'a>> {
match self {
IdValue::Valid(id) => Some(id),
IdValue::OtherNumber(text) if lenient => Some(Id::RawNumber(Cow::Borrowed(text))),
IdValue::Null if lenient => Some(Id::Null),
IdValue::Null | IdValue::OtherNumber(_) | IdValue::Invalid => None,
}
}
}
fn read_id(raw: &str) -> IdValue<'_> {
match raw.as_bytes().first() {
Some(b'"') => read_string(raw).map_or(IdValue::Invalid, |s| IdValue::Valid(Id::String(s))),
Some(b'n') => IdValue::Null,
Some(b'-' | b'0'..=b'9') => match Number::from_text(raw).and_then(|n| n.as_i64()) {
Some(n) => IdValue::Valid(Id::Number(n)),
None => IdValue::OtherNumber(raw),
},
_ => IdValue::Invalid,
}
}
#[cfg(feature = "std")]
pub(crate) fn read_member_id<'a>(
params: &'a str,
member: &str,
parser: &Parser,
lenient: bool,
) -> Option<Id<'a>> {
match read_id(read_member(params, member, parser)?) {
IdValue::Null => None,
other => other.into_request_id(lenient),
}
}
#[cfg(feature = "std")]
pub(crate) fn read_member<'a>(object: &'a str, member: &str, parser: &Parser) -> Option<&'a str> {
let mut reader = envelope_parser(parser).reader(object);
if !matches!(reader.next_event(), Ok(Some(Event::StartObject))) {
return None;
}
let mut found = None;
loop {
match reader.next_event() {
Ok(Some(Event::Key(key))) => {
let raw = reader.read_raw().ok()??;
if *key == *member && found.replace(raw).is_some() {
return None;
}
}
Ok(Some(Event::EndObject)) => return found,
_ => return None,
}
}
}
#[cfg(feature = "std")]
pub(crate) fn is_token(raw: &str) -> bool {
matches!(read_id(raw), IdValue::Valid(_))
}
fn read_string(raw: &str) -> Option<Cow<'_, str>> {
let inner = raw.strip_prefix('"')?.strip_suffix('"')?;
if !inner.contains('\\') {
return Some(Cow::Borrowed(inner));
}
match Reader::new(raw).next_event() {
Ok(Some(Event::String(s))) => Some(s),
_ => None,
}
}
fn classify<'a>(fields: Fields<'a>, parser: &Parser, limits: &Limits) -> Entry<'a> {
let lenient = limits.lenient_ids;
if fields.id_too_long(limits) {
let response =
fields.method.is_none() && (fields.result.is_some() || fields.error.is_some());
let max = limits.max_id_bytes;
return Err(Invalid {
id: None,
response,
error: ErrorObject::invalid_request(format!("an id may be at most {max} bytes")),
});
}
let id = fields.id.map(read_id);
let id_repeated = fields.id_repeated;
let valid_id = match &id {
Some(IdValue::Valid(id)) if !id_repeated => Some(id.clone()),
Some(IdValue::OtherNumber(text)) if lenient && !id_repeated => {
Some(Id::RawNumber(Cow::Borrowed(text)))
}
_ => None,
};
let version_ok = fields
.jsonrpc
.is_some_and(|v| v == "\"2.0\"" || read_string(v).is_some_and(|s| s == "2.0"));
if let Some(method) = fields.method {
let fail = |message: &'static str| {
Err(Invalid::request(
valid_id.clone(),
ErrorObject::invalid_request(message),
))
};
if let Some(name) = fields.duplicate {
return Err(Invalid::request(
valid_id.clone(),
ErrorObject::invalid_request(format!("the member `{name}` appears more than once")),
));
}
if !version_ok {
return fail("`jsonrpc` must be \"2.0\"");
}
let Some(method) = read_string(method) else {
return fail("`method` must be a string");
};
if fields.result.is_some() || fields.error.is_some() {
return fail("a request cannot have a `result` or an `error`");
}
let params = match fields.params {
None => None,
Some(p) if p.as_str() == "null" => None,
Some(p) if p.as_str().starts_with(['[', '{']) => Some(Raw::checked(p)),
Some(_) => return fail("`params` must be an array or an object"),
};
let Some(id) = id else {
return Ok(Message::Notification(Notification { method, params }));
};
let null = matches!(id, IdValue::Null);
return match id.into_request_id(lenient) {
Some(id) => Ok(Message::Request(Request { id, method, params })),
None if null => fail("a request id must not be null"),
None => fail("a request id must be a string or an integer"),
};
}
if fields.result.is_none() && fields.error.is_none() {
return Err(Invalid::request(
None,
ErrorObject::invalid_request("a message needs a `method`, or a `result` or an `error`"),
));
}
let fail = |message: Cow<'static, str>| {
Err(Invalid {
id: valid_id.clone(),
response: true,
error: ErrorObject::invalid_request(message),
})
};
if let Some(name) = fields.duplicate {
return fail(format!("the member `{name}` appears more than once").into());
}
if !version_ok {
return fail("`jsonrpc` must be \"2.0\"".into());
}
let result = match (fields.result, fields.error) {
(Some(_), Some(_)) => {
return fail("a response cannot have both `result` and `error`".into());
}
(Some(result), None) => Ok(Raw::checked(result)),
(None, Some(error)) => match read_error(error, parser) {
Ok(error) => Err(error),
Err(why) => return fail(format!("malformed `error`: {why}").into()),
},
(None, None) => return fail("a response needs a `result` or an `error`".into()),
};
match id {
None if result.is_err() => Ok(Message::Response(Response { id: None, result })),
None => fail("a successful response needs an `id`".into()),
Some(IdValue::OtherNumber(text)) if lenient => Ok(Message::Response(Response {
id: Some(Id::RawNumber(Cow::Borrowed(text))),
result,
})),
Some(IdValue::Invalid | IdValue::OtherNumber(_)) => {
fail("a response id must be a string, an integer, or null".into())
}
Some(IdValue::Null) if result.is_ok() => {
fail("a successful response needs a non-null `id`".into())
}
Some(IdValue::Null) => Ok(Message::Response(Response { id: None, result })),
Some(IdValue::Valid(id)) => Ok(Message::Response(Response {
id: Some(id),
result,
})),
}
}
fn read_error(raw: &str, parser: &Parser) -> Result<ErrorObject, &'static str> {
const NOT_AN_OBJECT: &str = "it must be an object with `code` and `message`";
let mut reader = envelope_parser(parser).reader(raw);
if !matches!(reader.next_event(), Ok(Some(Event::StartObject))) {
return Err(NOT_AN_OBJECT);
}
let (mut code, mut message, mut data) = (None, None, None::<RawValue<'_>>);
loop {
let key = match reader.next_event() {
Ok(Some(Event::Key(key))) => key,
Ok(Some(Event::EndObject)) => break,
_ => return Err(NOT_AN_OBJECT),
};
if *key == *"data" {
let Ok(Some(value)) = reader.read_raw_value() else {
return Err(NOT_AN_OBJECT);
};
if data.replace(value).is_some() {
return Err("a member appears more than once");
}
continue;
}
let Ok(Some(value)) = reader.read_raw() else {
return Err(NOT_AN_OBJECT);
};
let slot = match &*key {
"code" => &mut code,
"message" => &mut message,
_ => continue,
};
if slot.replace(value).is_some() {
return Err("a member appears more than once");
}
}
let code = code
.and_then(Number::from_text)
.and_then(|n| n.as_i64())
.ok_or("`code` must be an integer")?;
let message = message
.and_then(read_string)
.ok_or("`message` must be a string")?;
let data = data.map(|d| Raw::checked(d.into_owned()));
Ok(ErrorObject::from_parts(code, clip_owned(message), data))
}
fn clip_owned(message: Cow<'_, str>) -> String {
const MAX: usize = 4096;
if message.len() <= MAX {
return message.into_owned();
}
let mut end = MAX;
while !message.is_char_boundary(end) {
end -= 1;
}
String::from(&message[..end])
}
#[cfg(test)]
#[allow(clippy::panic)]
mod tests {
use alloc::string::ToString;
use super::*;
use crate::ErrorCode;
fn single(body: &str) -> Entry<'_> {
match decode(body.as_bytes(), &Limits::new()) {
Incoming::Single(entry) => entry,
Incoming::Batch(_) => panic!("unexpected batch"),
}
}
fn invalid(body: &str) -> Invalid<'_> {
match single(body) {
Err(invalid) => invalid,
Ok(message) => panic!("expected invalid, got {message}"),
}
}
#[test]
fn test_request_and_notification() {
let Ok(Message::Request(r)) =
single(r#"{"jsonrpc":"2.0","id":-5,"method":"m","params":{"a":1}}"#)
else {
panic!()
};
assert_eq!(r.id, Id::Number(-5));
assert!(matches!(r.method, Cow::Borrowed("m")));
assert_eq!(
r.params.map(|p| p.as_str().to_string()).as_deref(),
Some(r#"{"a":1}"#)
);
let Ok(Message::Notification(n)) =
single(r#"{"method":"x","jsonrpc":"2.0","params":null}"#)
else {
panic!()
};
assert_eq!(n.method, "x");
assert!(n.params.is_none());
}
#[test]
fn test_escaped_strings_decode() {
let Ok(Message::Request(r)) = single(r#"{"jsonrpc":"2.0","id":"a\nb","method":"m"}"#)
else {
panic!()
};
assert_eq!(r.id.as_str(), Some("a\nb"));
assert_eq!(r.method, "m");
}
#[test]
fn test_invalid_ids() {
for (id, answered) in [
("null", false),
("1.5", false),
("1e3", false),
("[1]", false),
("true", false),
("99999999999999999999", false),
] {
let body = alloc::format!(r#"{{"jsonrpc":"2.0","id":{id},"method":"m"}}"#);
let invalid = invalid(&body).into_owned();
assert!(!invalid.is_response());
assert_eq!(invalid.id().is_some(), answered, "{id}");
}
}
#[test]
fn test_shape_errors_keep_valid_id() {
for body in [
r#"{"id":3,"method":"m"}"#,
r#"{"jsonrpc":"1.0","id":3,"method":"m"}"#,
r#"{"jsonrpc":"2.0","id":3,"method":5}"#,
r#"{"jsonrpc":"2.0","id":3,"method":"m","params":"x"}"#,
r#"{"jsonrpc":"2.0","id":3,"method":"m","result":1}"#,
r#"{"jsonrpc":"2.0","id":3,"method":"m","params":[],"params":{}}"#,
] {
let invalid = invalid(body);
assert_eq!(invalid.id(), Some(&Id::Number(3)), "{body}");
assert_eq!(invalid.error().code(), ErrorCode::INVALID_REQUEST, "{body}");
}
assert!(
invalid(r#"{"jsonrpc":"2.0","id":3,"id":4,"method":"m"}"#)
.id()
.is_none()
);
}
#[test]
fn test_responses() {
let Ok(Message::Response(r)) = single(r#"{"jsonrpc":"2.0","id":2,"result":[1]}"#) else {
panic!()
};
assert_eq!(
r.result.map(|raw| raw.as_str().to_string()),
Ok("[1]".to_string())
);
let Ok(Message::Response(r)) = single(
r#"{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"x","data":{"k":[1]}}}"#,
) else {
panic!()
};
assert!(r.id.is_none());
let error = r.result.err();
assert_eq!(
error.as_ref().map(ErrorObject::code),
Some(ErrorCode::PARSE_ERROR)
);
assert_eq!(
error.as_ref().and_then(|e| e.data()).map(Raw::as_str),
Some(r#"{"k":[1]}"#)
);
}
#[test]
fn test_malformed_responses_are_response_like() {
for body in [
r#"{"jsonrpc":"2.0","id":2,"result":1,"error":{"code":1,"message":"m"}}"#,
r#"{"jsonrpc":"2.0","id":2,"error":{"code":1.5,"message":"m"}}"#,
r#"{"jsonrpc":"2.0","id":2,"error":{"message":"m"}}"#,
r#"{"jsonrpc":"2.0","id":2,"error":"oops"}"#,
r#"{"jsonrpc":"2.0","result":1}"#,
r#"{"jsonrpc":"2.0","id":null,"result":1}"#,
] {
let invalid = invalid(body);
assert!(invalid.is_response(), "{body}");
assert!(invalid.reply().is_none(), "{body}");
}
}
#[test]
fn test_not_messages() {
for (body, code) in [
("", ErrorCode::PARSE_ERROR),
("{", ErrorCode::PARSE_ERROR),
(r#"{"a":1} x"#, ErrorCode::PARSE_ERROR),
("\u{feff}{}", ErrorCode::PARSE_ERROR),
("1", ErrorCode::INVALID_REQUEST),
("{}", ErrorCode::INVALID_REQUEST),
("[]", ErrorCode::INVALID_REQUEST),
] {
let invalid = invalid(body);
assert_eq!(invalid.error().code(), code, "{body:?}");
assert!(invalid.id().is_none());
}
let not_utf8 = decode(b"{\"a\":\"\xff\"}", &Limits::new());
assert!(
matches!(not_utf8, Incoming::Single(Err(i)) if i.error().code() == ErrorCode::PARSE_ERROR)
);
}
#[test]
fn test_batch_elements() {
let body = br#"[1, [2, [3]], {"jsonrpc":"2.0","method":"n"}, {"foo":"boo"}]"#;
let Incoming::Batch(entries) = decode(body, &Limits::new()) else {
panic!()
};
assert_eq!(entries.len(), 4);
assert!(entries[0].is_err() && entries[1].is_err() && entries[3].is_err());
assert!(matches!(entries[2], Ok(Message::Notification(_))));
assert_eq!(
invalid(r#"[{"jsonrpc":"2.0","method":"n"}, {"#)
.error()
.code(),
ErrorCode::PARSE_ERROR
);
}
#[test]
fn test_batch_limit() {
let limits = Limits::new().with_max_batch(2);
let body = br#"[{"jsonrpc":"2.0","method":"n"},{"jsonrpc":"2.0","method":"n"}]"#;
assert!(matches!(decode(body, &limits), Incoming::Batch(e) if e.len() == 2));
let body = br#"[{"jsonrpc":"2.0","method":"n"},{"jsonrpc":"2.0","method":"n"},1]"#;
assert!(
matches!(decode(body, &limits), Incoming::Single(Err(i)) if i.error().code() == ErrorCode::INVALID_REQUEST)
);
}
#[test]
fn test_budget_errors_salvage_the_id() {
let limits = Limits::new().with_json(jsonx_lib::Limits::new().with_max_depth(2));
let body = br#"{"jsonrpc":"2.0","id":"q","method":"m","params":[[[1]]]}"#;
let Incoming::Single(Err(invalid)) = decode(body, &limits) else {
panic!()
};
assert_eq!(invalid.id(), Some(&Id::from("q")));
assert_eq!(invalid.error().code(), ErrorCode::INVALID_REQUEST);
let body = br#"{"id":"q","params":[[[1]]],"method":"m"}"#;
let Incoming::Single(Err(invalid)) = decode(body, &limits) else {
panic!()
};
assert!(invalid.id().is_none());
}
#[test]
fn test_write_round_trips() {
let messages = [
r#"{"jsonrpc":"2.0","id":"x\"y","method":"a/b","params":[1,{"k":null}]}"#,
r#"{"jsonrpc":"2.0","method":"n"}"#,
r#"{"jsonrpc":"2.0","id":1,"result":{"a":[]}}"#,
r#"{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"m","data":[true]}}"#,
];
for text in messages {
let Ok(message) = single(text) else {
panic!("{text}")
};
assert_eq!(message.to_string(), text);
}
}
}