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

mod common;
use common::{setup, start_gateway_session};
use refluxer::http::endpoints::guilds::CreateGuildChannel;
use refluxer::http::endpoints::webhooks::{CreateWebhook, ExecuteWebhook, ModifyWebhook};

#[tokio::test]
async fn test_webhook_crud_and_execute() {
    let (http, guild_id) = setup();
    let _gw = start_gateway_session().await;

    let channel = http
        .create_guild_channel(
            guild_id,
            &CreateGuildChannel::text("refluxer-test-webhooks"),
        )
        .await
        .expect("create channel failed");

    match http
        .create_webhook(channel.id, &CreateWebhook::new("refluxer-test-hook"))
        .await
    {
        Ok(webhook) => {
            assert_eq!(webhook.name.as_deref(), Some("refluxer-test-hook"));
            println!(
                "Created webhook: {} (id: {})",
                webhook.name.as_deref().unwrap_or("?"),
                webhook.id
            );

            let hooks = http
                .get_channel_webhooks(channel.id)
                .await
                .expect("get_channel_webhooks failed");
            assert!(hooks.iter().any(|h| h.id == webhook.id));

            let guild_hooks = http
                .get_guild_webhooks(guild_id)
                .await
                .expect("get_guild_webhooks failed");
            assert!(guild_hooks.iter().any(|h| h.id == webhook.id));

            let fetched = http
                .get_webhook(&webhook.id)
                .await
                .expect("get_webhook failed");
            assert_eq!(fetched.id, webhook.id);

            let modified = http
                .modify_webhook(
                    &webhook.id,
                    &ModifyWebhook::new().name("refluxer-renamed-hook"),
                )
                .await
                .expect("modify_webhook failed");
            assert_eq!(modified.name.as_deref(), Some("refluxer-renamed-hook"));

            if let Some(token) = &webhook.token {
                let _ = http
                    .execute_webhook(
                        &webhook.id,
                        token,
                        &ExecuteWebhook::new()
                            .content("Hello from webhook!")
                            .username("Refluxer Test"),
                    )
                    .await;
                println!("Webhook executed");
            }

            http.delete_webhook(&webhook.id)
                .await
                .expect("delete_webhook failed");

            println!("Webhook CRUD tests passed");
        }
        Err(refluxer::error::HttpError::Api { status: 403, .. }) => {
            println!("Bot lacks MANAGE_WEBHOOKS permission — skipping");
        }
        Err(e) => panic!("unexpected error: {e}"),
    }

    http.delete_channel(channel.id)
        .await
        .expect("cleanup channel failed");
}