refluxer 0.2.0

Rust API wrapper for Fluxer
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

mod common;
use common::setup;
use refluxer::http::endpoints::moderation::{CreateRole, ModifyRole};
use refluxer::model::permissions::Permissions;

#[tokio::test]
async fn test_role_crud() {
    let (http, guild_id) = setup();

    let role = http
        .create_guild_role(
            guild_id,
            &CreateRole::new("refluxer-test-role")
                .color(0xFF5500)
                .hoist(true)
                .permissions(Permissions::SEND_MESSAGES | Permissions::VIEW_CHANNEL),
        )
        .await
        .expect("create_guild_role failed");

    assert_eq!(role.name, "refluxer-test-role");
    assert_eq!(role.color, 0xFF5500);
    println!(
        "Created role: {} (id: {}, hoist: {})",
        role.name, role.id, role.hoist
    );

    let roles = http
        .get_guild_roles(guild_id)
        .await
        .expect("get_guild_roles failed");

    assert!(
        roles.iter().any(|r| r.id == role.id),
        "created role should be in the list"
    );

    let modified = http
        .modify_guild_role(
            guild_id,
            role.id,
            &ModifyRole::new()
                .name("refluxer-test-renamed")
                .color(0x00FF00),
        )
        .await
        .expect("modify_guild_role failed");

    assert_eq!(modified.name, "refluxer-test-renamed");
    assert_eq!(modified.color, 0x00FF00);

    http.delete_guild_role(guild_id, role.id)
        .await
        .expect("delete_guild_role failed");

    let roles_after = http
        .get_guild_roles(guild_id)
        .await
        .expect("get_guild_roles failed");

    assert!(
        !roles_after.iter().any(|r| r.id == role.id),
        "deleted role should not be in the list"
    );

    println!("Role CRUD tests passed");
}

#[tokio::test]
async fn test_add_remove_member_role() {
    let (http, guild_id) = setup();

    let me = http
        .get_current_user()
        .await
        .expect("get_current_user failed");

    let role = http
        .create_guild_role(guild_id, &CreateRole::new("refluxer-test-assign"))
        .await
        .expect("create_guild_role failed");

    match http.add_guild_member_role(guild_id, me.id, role.id).await {
        Ok(()) => {
            let member = http
                .get_guild_member(guild_id, me.id)
                .await
                .expect("get_guild_member failed");

            assert!(
                member.roles.contains(&role.id),
                "bot should have the assigned role"
            );

            http.remove_guild_member_role(guild_id, me.id, role.id)
                .await
                .expect("remove_guild_member_role failed");

            let member_after = http
                .get_guild_member(guild_id, me.id)
                .await
                .expect("get_guild_member failed");

            assert!(
                !member_after.roles.contains(&role.id),
                "bot should not have the role anymore"
            );

            println!("Member role assignment tests passed");
        }
        Err(refluxer::error::HttpError::Api { status: 403, .. }) => {
            println!("Bot lacks MANAGE_ROLES permission — skipping role assignment test");
        }
        Err(e) => panic!("unexpected error: {e}"),
    }

    http.delete_guild_role(guild_id, role.id)
        .await
        .expect("cleanup role failed");
}

#[tokio::test]
async fn test_guild_permissions_deserialized() {
    let (http, guild_id) = setup();

    let roles = http
        .get_guild_roles(guild_id)
        .await
        .expect("get_guild_roles failed");

    assert!(!roles.is_empty(), "guild should have at least one role");

    for role in &roles {
        println!(
            "Role: {} — permissions: {} (bits: {})",
            role.name,
            role.permissions,
            role.permissions.bits()
        );
    }
}