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
116
117
118
119
120
121
122
123
124
125
126

use crate::{
    api::params::permission::PermissionsOverwriteParams,
    category::{CategoriesList, ExistingCategory},
};

use super::{CategoriesParamsList, CategoryParams, CategoryParamsExtraChannelsStrategy};

impl From<&CategoriesList<ExistingCategory>> for CategoriesParamsList {
    fn from(categories: &CategoriesList<ExistingCategory>) -> Self {
        let items = categories.to_list().into_iter().map(Into::into).collect();

        CategoriesParamsList {
            items,
            ..Default::default()
        }
    }
}

impl From<&ExistingCategory> for CategoryParams {
    fn from(category: &ExistingCategory) -> Self {
        let permissions_overwrites: Vec<PermissionsOverwriteParams> = category
            .overwrites
            .to_list()
            .iter()
            .map(PermissionsOverwriteParams::from)
            .collect();

        Self {
            name: category.name.clone(),
            permissions_overwrites,
            extra_channels: CategoryParamsExtraChannelsStrategy::default(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        api::params::{
            category::{CategoriesParamsList, CategoryParams, CategoryParamsExtraChannelsStrategy},
            permission::PermissionsOverwriteParams,
        },
        category::{CategoriesList, ExistingCategory},
        permission::{
            Permission, PermissionsList, PermissionsOverwrite, PermissionsOverwritesList,
        },
        role::ExistingRole,
    };

    fn given_matching_existing_and_params(
        name: &str,
        role: &ExistingRole,
    ) -> (ExistingCategory, CategoryParams) {
        let existing = ExistingCategory {
            id: "some".to_string(),
            name: name.to_string(),
            overwrites: PermissionsOverwritesList::from(vec![PermissionsOverwrite {
                role: role.clone(),
                allow: PermissionsList::from(vec![Permission::ADMINISTRATOR]),
                deny: PermissionsList::from(vec![Permission::ADMINISTRATOR]),
            }]),
        };

        let params = CategoryParams {
            name: name.to_string(),
            permissions_overwrites: vec![PermissionsOverwriteParams {
                role: role.name.clone(),
                allow: vec![Permission::ADMINISTRATOR],
                deny: vec![Permission::ADMINISTRATOR],
            }],
            extra_channels: CategoryParamsExtraChannelsStrategy::Keep,
        };

        (existing, params)
    }

    fn given_matching_existing_list_and_params_list(
        name: &str,
        role: &ExistingRole,
    ) -> (CategoriesList<ExistingCategory>, CategoriesParamsList) {
        let (existing, params) = given_matching_existing_and_params(name, role);

        let existing_list = CategoriesList::from(vec![existing]);

        let params_list = CategoriesParamsList {
            items: vec![params],
            ..Default::default()
        };

        (existing_list, params_list)
    }

    fn given_existing_role(id: &str, name: &str) -> ExistingRole {
        ExistingRole {
            id: id.to_string(),
            name: name.to_string(),
            permissions: PermissionsList::new(),
            color: None,
            is_mentionable: true,
            show_in_sidebar: false,
        }
    }

    #[test]
    fn can_convert_existing_entity_to_params() {
        let name = "presto";
        let role = given_existing_role("kgj399sd", "Team01");
        let (existing, expected_params) = given_matching_existing_and_params(name, &role);

        let params = CategoryParams::from(&existing);

        assert_eq!(params, expected_params);
    }

    #[test]
    fn can_convert_existing_entities_list_to_params_list() {
        let name = "presto";
        let role = given_existing_role("kgj399sd", "Team01");
        let (existing_list, expected_params_list) =
            given_matching_existing_list_and_params_list(name, &role);

        let params = CategoriesParamsList::from(&existing_list);

        assert_eq!(params, expected_params_list);
    }
}