simplejrpc 0.1.0

Unix-socket JSON-RPC 2.0 SDK with middleware, config, and validation
Documentation
//! Public API tests for `simplejrpc::codec`.

use simplejrpc::codec::{
    decode_frame, encode_frame, FrameReader, FrameReaderMut, FrameReaderView,
    DEFAULT_MAX_FRAME_LEN,
};
use simplejrpc::error::{Error, Result};

#[test]
fn codec_roundtrip() {
    let body = br#"{"jsonrpc":"2.0","id":1,"method":"ping","params":{}}"#;
    let framed = encode_frame(body);
    assert_eq!(decode_frame(&framed).unwrap(), body);

    let mut r = FrameReader::new();
    r.push(&framed[..10]);
    assert!(r.try_next().unwrap().is_none());
    r.push(&framed[10..]);
    assert_eq!(r.try_next().unwrap().unwrap(), body);
}

#[test]
fn rejects_oversized_declared_length() {
    let header = format!("Content-Length: {}\r\n\r\n", DEFAULT_MAX_FRAME_LEN + 1);
    let err = decode_frame(header.as_bytes()).unwrap_err();
    assert!(err.to_string().contains("frame too large"));
}

#[test]
fn custom_limit_on_reader() {
    let mut r = FrameReader::with_max_frame_len(8);
    let body = b"123456789";
    let framed = encode_frame(body);
    r.push(&framed);
    assert!(r
        .try_next()
        .unwrap_err()
        .to_string()
        .contains("frame too large"));
}

#[test]
fn parts_roundtrip() {
    let mut r = FrameReader::with_max_frame_len(32);
    r.push(b"abc");
    let (buf, max) = r.into_parts();
    assert_eq!(buf, b"abc");
    assert_eq!(max, 32);
    let again = FrameReader::from_parts(buf, max);
    assert_eq!(again.buffered_len(), 3);
}

#[test]
fn override_try_next_rejects_empty() {
    struct NoEmpty(FrameReader);

    impl FrameReaderView for NoEmpty {
        fn max_frame_len(&self) -> usize {
            FrameReaderView::max_frame_len(&self.0)
        }
        fn buffer(&self) -> &[u8] {
            FrameReaderView::buffer(&self.0)
        }
    }

    impl FrameReaderMut for NoEmpty {
        fn buffer_mut(&mut self) -> &mut Vec<u8> {
            FrameReaderMut::buffer_mut(&mut self.0)
        }
        fn set_max_frame_len(&mut self, max: usize) {
            FrameReaderMut::set_max_frame_len(&mut self.0, max)
        }
        fn try_next(&mut self) -> Result<Option<Vec<u8>>> {
            match FrameReaderMut::try_next(&mut self.0)? {
                Some(body) if body.is_empty() => {
                    Err(Error::Protocol("empty body rejected".into()))
                }
                other => Ok(other),
            }
        }
    }

    let mut r = NoEmpty(FrameReader::new());
    FrameReaderMut::push(&mut r, &encode_frame(b""));
    assert!(FrameReaderMut::try_next(&mut r)
        .unwrap_err()
        .to_string()
        .contains("empty body"));

    FrameReaderMut::push(&mut r, &encode_frame(b"ok"));
    assert_eq!(FrameReaderMut::try_next(&mut r).unwrap().unwrap(), b"ok");
}