jsonapis/builders/
error_source.rs

1use super::*;
2
3#[derive(Clone, Debug, Default, Eq, PartialEq)]
4pub struct ErrorSourceBuilder {
5    pointer: Option<String>,
6    parameter: Option<String>,
7}
8
9impl Builder<'_> for ErrorSourceBuilder {
10    type Entity = ErrorSource;
11
12    fn finish(self) -> Result<Self::Entity, BuildErrors> {
13        Ok(Self::Entity {
14            pointer: self.pointer,
15            parameter: self.parameter,
16        })
17    }
18}
19
20impl ErrorSourceBuilder {
21    pub fn pointer<P: ToString>(self, pointer: P) -> Self {
22        Self {
23            pointer: Some(pointer.to_string()),
24            ..self
25        }
26    }
27
28    pub fn parameter<P: ToString>(self, parameter: P) -> Self {
29        Self {
30            parameter: Some(parameter.to_string()),
31            ..self
32        }
33    }
34}
35
36impl From<ErrorSource> for ErrorSourceBuilder {
37    fn from(error_source: ErrorSource) -> Self {
38        Self {
39            pointer: error_source.pointer,
40            parameter: error_source.parameter,
41        }
42    }
43}
44
45#[cfg(test)]
46mod tests {
47    use super::*;
48
49    #[test]
50    fn empty() {
51        assert_eq!(
52            ErrorSourceBuilder::default().unwrap(),
53            ErrorSource {
54                pointer: None,
55                parameter: None,
56            },
57        );
58    }
59
60    #[test]
61    fn full() {
62        assert_eq!(
63            ErrorSourceBuilder::default()
64                .pointer("/foo/0/bar/1")
65                .parameter("car")
66                .unwrap(),
67            ErrorSource {
68                pointer: Some("/foo/0/bar/1".into()),
69                parameter: Some("car".into()),
70            },
71        );
72    }
73
74    #[test]
75    fn with_pointer() {
76        assert_eq!(
77            ErrorSourceBuilder::default()
78                .pointer("/foo/0/bar/1")
79                .unwrap(),
80            ErrorSource {
81                pointer: Some("/foo/0/bar/1".into()),
82                parameter: None,
83            },
84        );
85    }
86
87    #[test]
88    fn with_parameter() {
89        assert_eq!(
90            ErrorSourceBuilder::default().parameter("car").unwrap(),
91            ErrorSource {
92                pointer: None,
93                parameter: Some("car".into()),
94            },
95        );
96    }
97
98    #[test]
99    fn implicit_from_entity() {
100        let error_source = ErrorSource {
101            pointer: Some("/foo/0/bar/1".into()),
102            parameter: Some("car".into()),
103        };
104
105        let builder: ErrorSourceBuilder = error_source.clone().into();
106
107        assert_eq!(builder.unwrap(), error_source);
108    }
109}