twilight_model/channel/message/
reference.rs

1use crate::id::{
2    marker::{ChannelMarker, GuildMarker, MessageMarker},
3    Id,
4};
5use serde::{Deserialize, Serialize};
6
7use super::reference_type::MessageReferenceType;
8
9/// Message reference struct.
10#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
11pub struct MessageReference {
12    /// Originating message's channel ID.
13    ///
14    /// Note: optional when creating a reply, but always present when receiving
15    /// an event or response containing this model.
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub channel_id: Option<Id<ChannelMarker>>,
18    /// Originating message's guild ID.
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub guild_id: Option<Id<GuildMarker>>,
21    /// The type of reference.
22    ///
23    /// Defaults to [`MessageReferenceType::Default`].
24    #[serde(default, rename = "type")]
25    pub kind: MessageReferenceType,
26    /// Originating message's ID.
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub message_id: Option<Id<MessageMarker>>,
29    /// Whether to error if the referenced message doesn't exist instead of
30    /// sending a normal message.
31    ///
32    /// Defaults to true.
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub fail_if_not_exists: Option<bool>,
35}
36
37#[cfg(test)]
38mod tests {
39    use super::MessageReference;
40    use crate::{channel::message::reference_type::MessageReferenceType, id::Id};
41    use serde_test::Token;
42
43    #[test]
44    fn minimal() {
45        let value = MessageReference {
46            kind: MessageReferenceType::Default,
47            channel_id: Some(Id::new(1)),
48            guild_id: None,
49            message_id: None,
50            fail_if_not_exists: None,
51        };
52
53        serde_test::assert_tokens(
54            &value,
55            &[
56                Token::Struct {
57                    name: "MessageReference",
58                    len: 2,
59                },
60                Token::Str("channel_id"),
61                Token::Some,
62                Token::NewtypeStruct { name: "Id" },
63                Token::Str("1"),
64                Token::Str("type"),
65                Token::U8(0),
66                Token::StructEnd,
67            ],
68        );
69    }
70
71    #[test]
72    fn complete() {
73        let value = MessageReference {
74            channel_id: Some(Id::new(1)),
75            guild_id: Some(Id::new(2)),
76            kind: MessageReferenceType::Default,
77            message_id: Some(Id::new(3)),
78            fail_if_not_exists: Some(false),
79        };
80
81        serde_test::assert_tokens(
82            &value,
83            &[
84                Token::Struct {
85                    name: "MessageReference",
86                    len: 5,
87                },
88                Token::Str("channel_id"),
89                Token::Some,
90                Token::NewtypeStruct { name: "Id" },
91                Token::Str("1"),
92                Token::Str("guild_id"),
93                Token::Some,
94                Token::NewtypeStruct { name: "Id" },
95                Token::Str("2"),
96                Token::Str("type"),
97                Token::U8(0),
98                Token::Str("message_id"),
99                Token::Some,
100                Token::NewtypeStruct { name: "Id" },
101                Token::Str("3"),
102                Token::Str("fail_if_not_exists"),
103                Token::Some,
104                Token::Bool(false),
105                Token::StructEnd,
106            ],
107        );
108    }
109}