non_blank_string_rs/
lib.rs

1use std::fmt::{Display, Formatter};
2use std::ops::Deref;
3use std::str::FromStr;
4
5use serde::{Deserialize, Serialize};
6
7use crate::error::StringValueError;
8
9pub mod error;
10
11#[cfg(feature = "utils")]
12pub mod utils;
13
14pub type RequestId = NonBlankString;
15
16#[derive(Serialize, Deserialize, PartialEq, Eq, Ord, PartialOrd, Hash, Clone, Debug)]
17#[serde(try_from = "String", into = "String")]
18pub struct NonBlankString(String);
19
20impl FromStr for NonBlankString {
21    type Err = StringValueError;
22
23    fn from_str(value: &str) -> Result<Self, Self::Err> {
24        if value.len() > 0 {
25            Ok(Self(value.to_string()))
26        } else {
27            Err(StringValueError::ParseError)
28        }
29    }
30}
31
32impl AsRef<str> for NonBlankString {
33    fn as_ref(&self) -> &str {
34        &self.0
35    }
36}
37
38impl TryFrom<String> for NonBlankString {
39    type Error = StringValueError;
40
41    fn try_from(value: String) -> Result<Self, Self::Error> {
42        NonBlankString::from_str(&value)
43    }
44}
45
46impl From<NonBlankString> for String {
47    fn from(value: NonBlankString) -> Self {
48        value.0
49    }
50}
51
52impl Deref for NonBlankString {
53    type Target = str;
54
55    fn deref(&self) -> &Self::Target {
56        &self.0
57    }
58}
59
60impl Display for NonBlankString {
61    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
62        write!(f, "{}", self.0)
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use std::str::FromStr;
69
70    use fake::{Fake, Faker};
71    use serde::{Deserialize, Serialize};
72
73    use crate::NonBlankString;
74
75    #[test]
76    fn return_string_value_for_non_blank_string() {
77        let value = get_random_string();
78        assert_eq!(value, NonBlankString::from_str(&value).unwrap().as_ref());
79    }
80
81    #[test]
82    fn return_error_for_blank_string() {
83        assert!(NonBlankString::from_str("").is_err());
84
85        let value = "".parse::<NonBlankString>();
86        assert!(value.is_err())
87    }
88
89    #[derive(Serialize, Deserialize, PartialEq, Debug)]
90    struct Demo {
91        pub login: NonBlankString,
92    }
93
94    #[test]
95    fn serialization_deserialization_test() {
96        let value = get_random_string();
97
98        let entity = Demo {
99            login: NonBlankString::from_str(&value).unwrap(),
100        };
101
102        let json = serde_json::to_string(&entity).unwrap();
103
104        let expected_json = format!("{{\"login\":\"{}\"}}", value);
105
106        assert_eq!(json, expected_json);
107
108        let result_entity = serde_json::from_str::<Demo>(&expected_json).unwrap();
109
110        assert_eq!(result_entity, entity);
111    }
112
113    #[test]
114    fn serialization_deserialization_test_for_string_and_blank_value() {
115        let json = "{\"login\":\"\"}".to_string();
116        match serde_json::from_str::<Demo>(&json) {
117            Ok(_) => panic!("error expected"),
118            Err(e) => println!("{}", e),
119        }
120    }
121
122    #[test]
123    fn use_as_str_test() {
124        let non_blank_string = NonBlankString::from_str(&get_random_string()).unwrap();
125        assert_str_func(&non_blank_string);
126    }
127
128    fn assert_str_func(_: &str) {
129        assert!(true)
130    }
131
132    fn get_random_string() -> String {
133        Faker.fake::<String>()
134    }
135}
non_blank_string_rs/lib.rs

non_blank_string_rs/
lib.rs
