asserhttp 0.7.1

Fluent http response assertions
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

use crate::AsserhttpError;
use http_types::headers::HeaderName;

#[derive(Debug, Clone)]
pub struct HeaderKey(String);

impl<'a> From<&'a str> for HeaderKey {
    fn from(name: &'a str) -> Self {
        Self(name.to_string())
    }
}

impl<'a> From<&'a String> for HeaderKey {
    fn from(name: &'a String) -> Self {
        Self(name.to_string())
    }
}

impl From<String> for HeaderKey {
    fn from(name: String) -> Self {
        Self(name)
    }
}

impl From<HeaderName> for HeaderKey {
    fn from(name: HeaderName) -> Self {
        Self(name.as_str().to_string())
    }
}

impl std::ops::Deref for HeaderKey {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl AsRef<str> for HeaderKey {
    fn as_ref(&self) -> &str {
        self.0.as_str()
    }
}

impl std::fmt::Display for HeaderKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Eq for HeaderKey {}

impl PartialEq for HeaderKey {
    fn eq(&self, other: &Self) -> bool {
        self.eq_ignore_ascii_case(other)
    }
}

impl HeaderKey {
    pub fn try_assert_contained(&self, actual_keys: Vec<HeaderKey>) -> crate::AsserhttpResult<()> {
        if !actual_keys.contains(self) {
            return Err(AsserhttpError::HeaderAbsent { key: self.clone() });
        }
        Ok(())
    }

    pub fn try_assert_absent(&self, actual_keys: Vec<HeaderKey>) -> crate::AsserhttpResult<()> {
        if actual_keys.contains(self) {
            return Err(AsserhttpError::HeaderPresent { key: self.clone() });
        }
        Ok(())
    }
}