sparkle_interactions 0.16.0

Safe, concise Discord interaction handling for Twilight
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

#![expect(missing_docs, reason = "this is a test file")]
#![cfg(test)]

mod common;

use std::time::Duration;

use common::{interaction_handle, progress_embed, send_component_message, success_embed};
use sparkle_interactions::builder::{InteractionResponseBuilder, component::TextInputBuilder};
use tokio::time::sleep;
use twilight_util::builder::InteractionResponseDataBuilder;

#[tokio::test]
async fn test_modal() -> Result<(), anyhow::Error> {
    send_component_message().await?;
    let handle = interaction_handle().await?;

    handle
        .respond(
            InteractionResponseBuilder::show_modal(
                "Test Modal".to_owned(),
                "sparkly_modal".to_owned(),
            )
            .text_input(
                TextInputBuilder::new(
                    "Test Text Input".to_owned(),
                    "sparkly_text_input".to_owned(),
                )
                .placeholder("It's normal for the submit button to fail.".to_owned())
                .build(),
            )
            .build(),
        )
        .await?;

    Ok(())
}

#[tokio::test]
async fn test_respond_on_delay() -> Result<(), anyhow::Error> {
    let handle = interaction_handle().await?.respond_on_delay(
        InteractionResponseBuilder::send_message(
            InteractionResponseDataBuilder::new()
                .embeds([progress_embed()
                    .description(
                        "This response has been sent successfully on delay. Another response \
                         should be sent in a second.",
                    )
                    .build()])
                .build(),
        ),
        Duration::from_secs(2),
    );

    sleep(Duration::from_secs(3)).await;

    handle
        .respond(InteractionResponseBuilder::send_message(
            InteractionResponseDataBuilder::new()
                .embeds([success_embed()
                    .description(
                        "The final response has been sent successfully. Sending a response on a \
                         delay is successful.",
                    )
                    .build()])
                .build(),
        ))
        .await?;

    Ok(())
}

#[tokio::test]
async fn test_send_message() -> Result<(), anyhow::Error> {
    let handle = interaction_handle().await?;

    handle
        .respond(InteractionResponseBuilder::send_message(
            InteractionResponseDataBuilder::new()
                .embeds([success_embed()
                    .description(
                        "The response has been sent successfully. Responding with a send message \
                         is successful.",
                    )
                    .build()])
                .build(),
        ))
        .await?;

    Ok(())
}

#[tokio::test]
async fn test_update_message() -> Result<(), anyhow::Error> {
    send_component_message().await?;
    let handle = interaction_handle().await?;

    handle
        .respond(InteractionResponseBuilder::update_message(
            InteractionResponseDataBuilder::new()
                .embeds([success_embed()
                    .description(
                        "The response has been sent successfully. Responding to a component with \
                         an update message response is successful.",
                    )
                    .build()])
                .build(),
        ))
        .await?;

    Ok(())
}