storage/
validation.rs

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
use data_model::{Error as DataModelError, User, UserValidationError};
use crate::Error;

/// Validates the fields within a user object for create/update within a store
///
/// # Examples
///
/// Validate the default user content. This will fail as the default User content
/// contains some empty fields that need to be populated prior to saving to a store.
///
/// ```
/// use data_model::User;
/// use storage::validation::validate_user_fields;
/// use uuid::Uuid;
///
/// let user = User::default();
/// match validate_user_fields(&user) {
///     Ok(_) => {
///         println!("The User object passed the field validation test for storage");
///     }
///     Err(error) => {
///         println!(
///             "The User object failed the field validation test for storage => {}",
///             error
///         );
///     }
/// }
/// ```
pub fn validate_user_fields(user: &User) -> Result<(), Error> {
    if let Err(DataModelError::UserValidation(error)) = user.validate() {
        match error {
            UserValidationError::EmailInvalid => return Err(Error::UserEmailInvalid()),
            UserValidationError::IdMissing => return Err(Error::UserIdMissing()),
            UserValidationError::PasswordMissing => return Err(Error::UserPasswordMissing()),
            UserValidationError::UsernameMissing => return Err(Error::UserNameMissing()),
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use uuid::Uuid;

    // Initialize a User struct
    fn init_valid_user() -> User {
        User {
            id: User::new_id(),
            is_admin: false,
            username: "john_smith".to_string(),
            full_name:"John Smith".to_string(),
            email: "john_smith@company.com".to_string(),
            password_hash: "a_password_hash".to_string(),
            api_key: User::new_api_key(),
        }
    }

    fn run_validation_test(user: &User) {
        if let Err(error) = validate_user_fields(user) {
            panic!("{}'", error);
        }
    }

    #[test]
    fn validation_should_succeed_for_valid_user() {
        let user = init_valid_user();
        run_validation_test(&user);
    }

    #[test]
    #[should_panic(expected = "No id provided for the user")]
    fn validation_should_fail_for_missing_id() {
        let mut user = init_valid_user();
        user.id = Uuid::nil();
        run_validation_test(&user);
    }

    #[test]
    #[should_panic(expected = "No username provided for the user")]
    fn validation_should_fail_for_missing_username() {
        let mut user = init_valid_user();
        user.username = "".to_string();
        run_validation_test(&user);
    }

    #[test]
    #[should_panic(expected = "No password provided for the user")]
    fn validation_should_fail_for_missing_password() {
        let mut user = init_valid_user();
        user.password_hash = "".to_string();
        run_validation_test(&user);
    }

    #[test]
    fn validation_should_succeed_for_empty_email() {
        let mut user = init_valid_user();
        user.email = "".to_string();
        run_validation_test(&user);
    }

    #[test]
    #[should_panic(expected = "The email address is invalid")]
    fn validation_should_fail_for_invalid_email() {
        let mut user = init_valid_user();
        user.email = "bad_email_address".to_string();
        run_validation_test(&user);
    }

}