pata 0.0.1

A fast, lightweight, and evidence-driven email validation library for Rust
Documentation
//! Bounded provider response decoding.

use serde::de::DeserializeOwned;
use tez::{BodyExt as _, HttpBody as _};

pub(super) fn retry_after(response: &tez::Response) -> Option<std::time::Duration> {
    parse_retry_after(response.headers().get("retry-after")?.to_str().ok()?)
}

fn parse_retry_after(value: &str) -> Option<std::time::Duration> {
    value
        .parse::<u64>()
        .ok()
        .map(std::time::Duration::from_secs)
}

pub(super) async fn json<T>(response: tez::Response, limit: usize) -> Result<T, ()>
where
    T: DeserializeOwned,
{
    let content_length = response.content_length();
    decode_json(response.into_body(), content_length, limit).await
}

async fn decode_json<T>(
    mut body: tez::Body,
    content_length: Option<u64>,
    limit: usize,
) -> Result<T, ()>
where
    T: DeserializeOwned,
{
    if content_length.is_some_and(|length| length > limit as u64) {
        return Err(());
    }

    if body.size_hint().lower() > limit as u64 {
        return Err(());
    }
    let mut bytes = Vec::new();
    while let Some(frame) = body.frame().await {
        let frame = frame.map_err(|_| ())?;
        if let Ok(data) = frame.into_data() {
            let length = bytes.len().checked_add(data.len()).ok_or(())?;
            if length > limit {
                return Err(());
            }
            bytes.extend_from_slice(&data);
        }
    }
    serde_json::from_slice(&bytes).map_err(|_| ())
}

#[cfg(test)]
mod tests {
    use futures_executor::block_on;
    use serde::Deserialize;

    use super::{decode_json, parse_retry_after};

    #[derive(Debug, Deserialize, Eq, PartialEq)]
    struct Payload {
        value: String,
    }

    #[test]
    fn retry_after_accepts_only_whole_seconds() {
        assert_eq!(
            parse_retry_after("42"),
            Some(std::time::Duration::from_secs(42))
        );
        assert_eq!(parse_retry_after("tomorrow"), None);
    }

    #[test]
    fn bounded_json_accepts_a_valid_body() {
        let payload = block_on(decode_json::<Payload>(
            tez::Body::from(r#"{"value":"ok"}"#),
            None,
            64,
        ));

        assert_eq!(
            payload,
            Ok(Payload {
                value: "ok".to_owned()
            })
        );
    }

    #[test]
    fn bounded_json_rejects_declared_hinted_and_observed_overflow() {
        let declared = block_on(decode_json::<Payload>(tez::Body::empty(), Some(65), 64));
        let hinted = block_on(decode_json::<Payload>(
            tez::Body::from(r#"{"value":"too long"}"#),
            None,
            8,
        ));
        let body = tez::Body::stream(futures_util::stream::iter([
            Ok::<_, std::io::Error>(vec![b'a'; 5]),
            Ok(vec![b'b'; 5]),
        ]));
        let observed = block_on(decode_json::<Payload>(body, None, 8));

        assert_eq!(declared, Err(()));
        assert_eq!(hinted, Err(()));
        assert_eq!(observed, Err(()));
    }

    #[test]
    fn bounded_json_rejects_malformed_input() {
        let payload = block_on(decode_json::<Payload>(
            tez::Body::from("not json"),
            None,
            64,
        ));

        assert_eq!(payload, Err(()));
    }
}