apollo-errors-derive 0.5.0

Proc macro for deriving apollo-errors::Error trait
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! HTTP header attribute parsing

use syn::{Attribute, Lit, Result};

/// Parse #[http_header("Header-Name")] attribute from a field
pub(crate) fn parse_http_header(attrs: &[Attribute]) -> Result<Option<String>> {
    let mut result: Option<String> = None;

    for attr in attrs {
        if attr.path().is_ident("http_header") {
            if result.is_some() {
                return Err(syn::Error::new_spanned(
                    attr,
                    "duplicate #[http_header] attribute",
                ));
            }

            let lit: Lit = attr.parse_args()?;
            if let Lit::Str(s) = lit {
                let header_name = s.value();

                if let Err(e) = http::HeaderName::from_bytes(header_name.as_bytes()) {
                    return Err(syn::Error::new_spanned(
                        attr,
                        format!("invalid HTTP header name: {e}"),
                    ));
                }

                result = Some(header_name);
            } else {
                return Err(syn::Error::new_spanned(
                    attr,
                    "expected string literal for http_header name",
                ));
            }
        }
    }

    Ok(result)
}

#[cfg(test)]
mod tests {
    use super::*;
    use syn::parse_quote;

    #[test]
    fn parse_single_http_header() {
        let attrs: Vec<Attribute> = vec![parse_quote!(#[http_header("X-Request-Id")])];
        let result = parse_http_header(&attrs).unwrap();
        assert_eq!(result, Some("X-Request-Id".to_string()));
    }

    #[test]
    fn parse_no_http_header() {
        let attrs: Vec<Attribute> = vec![parse_quote!(#[extension])];
        let result = parse_http_header(&attrs).unwrap();
        assert_eq!(result, None);
    }

    #[test]
    fn reject_duplicate_http_header() {
        let attrs: Vec<Attribute> = vec![
            parse_quote!(#[http_header("X-First")]),
            parse_quote!(#[http_header("X-Second")]),
        ];
        let result = parse_http_header(&attrs);
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("duplicate"));
    }

    #[test]
    fn reject_invalid_header_name() {
        let attrs: Vec<Attribute> = vec![parse_quote!(#[http_header("Invalid Header")])];
        let result = parse_http_header(&attrs);
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("invalid"));
    }
}