disma 0.16.4

Discord server management has never been easier!
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
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
111
112
113
114
115

use std::sync::Arc;

use crate::{
    permission::PermissionsList,
    role::{AwaitingRole, AwaitingRolesList, ExtraRolesStrategy, KeepExtraRoles, RemoveExtraRoles},
};

use super::{RoleParams, RoleParamsExtraItemsStrategy, RolesParamsList};

impl RolesParamsList {
    pub fn into(self) -> AwaitingRolesList {
        let items = self
            .items
            .into_iter()
            .map(|role| role.into())
            .collect::<Vec<AwaitingRole>>()
            .into();

        AwaitingRolesList {
            items,
            extra_items_strategy: self.extra_items.into(),
        }
    }
}

impl Into<Arc<dyn ExtraRolesStrategy>> for RoleParamsExtraItemsStrategy {
    fn into(self) -> Arc<dyn ExtraRolesStrategy> {
        match self {
            RoleParamsExtraItemsStrategy::Keep => Arc::from(KeepExtraRoles {}),
            RoleParamsExtraItemsStrategy::Remove => Arc::from(RemoveExtraRoles {}),
        }
    }
}

impl Into<AwaitingRole> for RoleParams {
    fn into(self) -> AwaitingRole {
        AwaitingRole {
            name: self.name,
            permissions: PermissionsList::from(self.permissions),
            color: self.color.map(|color| color.to_lowercase()),
            is_mentionable: self.is_mentionable,
            show_in_sidebar: self.show_in_sidebar,
        }
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use crate::{
        api::params::role::{RoleParams, RoleParamsExtraItemsStrategy, RolesParamsList},
        permission::{Permission, PermissionsList},
        role::{AwaitingRole, AwaitingRolesList, KeepExtraRoles, RolesList},
    };

    fn given_matching_params_and_awaiting(name: &str) -> (RoleParams, AwaitingRole) {
        let params = RoleParams {
            name: name.to_string(),
            color: Some("826d5f".to_string()),
            is_mentionable: true,
            show_in_sidebar: false,
            permissions: vec![Permission::ADMINISTRATOR],
        };

        let awaiting = AwaitingRole {
            name: name.to_string(),
            color: Some("826d5f".to_string()),
            is_mentionable: true,
            show_in_sidebar: false,
            permissions: PermissionsList::from(vec![Permission::ADMINISTRATOR]),
        };

        (params, awaiting)
    }

    fn given_matching_params_list_and_awaiting_list(
        name: &str,
    ) -> (RolesParamsList, AwaitingRolesList) {
        let (params, awaiting) = given_matching_params_and_awaiting(name);

        let params_list = RolesParamsList {
            items: vec![params],
            extra_items: RoleParamsExtraItemsStrategy::Keep,
        };

        let awaiting_list = AwaitingRolesList {
            items: RolesList::from(vec![awaiting]),
            extra_items_strategy: Arc::from(KeepExtraRoles {}),
        };

        (params_list, awaiting_list)
    }

    #[test]
    fn can_convert_params_to_awaiting() {
        let name = "Team10";
        let (params, expected_awaiting) = given_matching_params_and_awaiting(name);

        let awaiting: AwaitingRole = params.into();

        assert_eq!(awaiting, expected_awaiting);
    }

    #[test]
    fn can_convert_compressed_params_to_awaiting_entity() {
        let name = "presto";
        let (params_list, expected_awaiting_list) =
            given_matching_params_list_and_awaiting_list(name);

        let awaiting_list: AwaitingRolesList = params_list.into();

        assert_eq!(awaiting_list, expected_awaiting_list);
    }
}