intrepid_core/extract/
http_meta.rs

use crate::{Context, Frame, HttpFrameMeta};

use super::{Extractor, MessageFrameError, MessageMetaJson};

/// Extract the URI of a message from a frame.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HttpMeta(pub HttpFrameMeta);

impl<State> Extractor<State> for HttpMeta {
    type Error = MessageFrameError;

    fn extract(frame: Frame, context: &Context<State>) -> Result<Self, Self::Error>
    where
        Self: Sized,
    {
        let MessageMetaJson(http_meta) = MessageMetaJson::<HttpFrameMeta>::extract(frame, context)?;

        Ok(Self(http_meta))
    }
}

#[tokio::test]
async fn getting_method() -> Result<(), Box<dyn std::error::Error>> {
    use crate::HttpRequestFrame;
    use axum::http::Request;

    let cases = [
        "GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "CONNECT", "PATCH", "TRACE",
    ];

    for method in cases {
        let request = HttpRequestFrame::from(
            Request::builder()
                .method(method)
                .uri("/test")
                .body(axum::body::Body::default())?,
        );

        let context = Context::<()>::default();
        let HttpMeta(meta) = HttpMeta::extract(request.into_frame().await, &context)?;

        assert_eq!(meta.method, method);
    }

    Ok(())
}

#[test]
fn failure() -> Result<(), MessageFrameError> {
    use crate::{Error, ExtractorError};

    let context = Context::<()>::default();
    let result = HttpMeta::extract_from_frame_and_state(Frame::default(), &context);

    assert!(matches!(
        result.unwrap_err(),
        Error::ExtractorError(ExtractorError::MessageFrameError(
            MessageFrameError::WrongFrame(_)
        ))
    ),);

    Ok(())
}
intrepid_core/extract/http_meta.rs

intrepid_core/extract/
http_meta.rs
