slack_messaging/blocks/
header.rs

1use crate::composition_objects::{Plain, Text};
2use crate::validators::*;
3
4use serde::Serialize;
5use slack_messaging_derive::Builder;
6
7/// [Header block](https://docs.slack.dev/reference/block-kit/blocks/header-block)
8/// representation.
9///
10/// # Fields and Validations
11///
12/// For more details, see the [official
13/// documentation](https://docs.slack.dev/reference/block-kit/blocks/header-block).
14///
15/// | Field | Type | Required | Validation |
16/// |-------|------|----------|------------|
17/// | text | [Text]<[Plain]> | Yes | Maximum 150 characters |
18/// | block_id | String | No | Maximum 255 characters |
19///
20/// # Example
21///
22/// ```
23/// use slack_messaging::plain_text;
24/// use slack_messaging::blocks::Header;
25/// # use std::error::Error;
26///
27/// # fn try_main() -> Result<(), Box<dyn Error>> {
28/// let header = Header::builder()
29///     .text(plain_text!("Budget Performance")?)
30///     .block_id("header_1")
31///     .build()?;
32///
33/// let expected = serde_json::json!({
34///     "type": "header",
35///     "block_id": "header_1",
36///     "text": {
37///         "type": "plain_text",
38///         "text": "Budget Performance"
39///     }
40/// });
41///
42/// let json = serde_json::to_value(header).unwrap();
43///
44/// assert_eq!(json, expected);
45/// #     Ok(())
46/// # }
47/// # fn main() {
48/// #     try_main().unwrap()
49/// # }
50/// ```
51#[derive(Debug, Clone, Serialize, PartialEq, Builder)]
52#[serde(tag = "type", rename = "header")]
53pub struct Header {
54    #[builder(validate("required", "text_object::max_150"))]
55    pub(crate) text: Option<Text<Plain>>,
56
57    #[serde(skip_serializing_if = "Option::is_none")]
58    #[builder(validate("text::max_255"))]
59    pub(crate) block_id: Option<String>,
60}
61
62#[cfg(test)]
63mod tests {
64    use super::*;
65    use crate::composition_objects::test_helpers::*;
66    use crate::errors::*;
67
68    #[test]
69    fn it_implements_builder() {
70        let expected = Header {
71            text: Some(plain_text("foo")),
72            block_id: Some("header_0".into()),
73        };
74
75        let val = Header::builder()
76            .set_text(Some(plain_text("foo")))
77            .set_block_id(Some("header_0"))
78            .build()
79            .unwrap();
80
81        assert_eq!(val, expected);
82
83        let val = Header::builder()
84            .text(plain_text("foo"))
85            .block_id("header_0")
86            .build()
87            .unwrap();
88
89        assert_eq!(val, expected);
90    }
91
92    #[test]
93    fn it_requires_text_field() {
94        let err = Header::builder().build().unwrap_err();
95        assert_eq!(err.object(), "Header");
96
97        let errors = err.field("text");
98        assert!(errors.includes(ValidationErrorKind::Required));
99    }
100
101    #[test]
102    fn it_requires_text_less_than_150_characters_long() {
103        let err = Header::builder()
104            .text(plain_text("a".repeat(151)))
105            .build()
106            .unwrap_err();
107        assert_eq!(err.object(), "Header");
108
109        let errors = err.field("text");
110        assert!(errors.includes(ValidationErrorKind::MaxTextLength(150)));
111    }
112
113    #[test]
114    fn it_requires_block_id_less_than_255_characters_long() {
115        let err = Header::builder()
116            .text(plain_text("foo"))
117            .block_id("a".repeat(256))
118            .build()
119            .unwrap_err();
120        assert_eq!(err.object(), "Header");
121
122        let errors = err.field("block_id");
123        assert!(errors.includes(ValidationErrorKind::MaxTextLength(255)));
124    }
125}