BlockKitTest.java

package test_locally.api.model.block;

import com.google.gson.Gson;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;
import com.slack.api.model.Message;
import com.slack.api.model.block.*;
import com.slack.api.model.block.composition.ActionCellObject;
import com.slack.api.model.block.composition.ConfirmationDialogObject;
import com.slack.api.model.block.composition.RawNumberObject;
import com.slack.api.model.block.composition.RawTextObject;
import com.slack.api.model.block.composition.TableCell;
import com.slack.api.model.block.composition.UnknownTableCell;
import com.slack.api.model.block.element.*;
import com.slack.api.model.view.View;
import org.junit.Test;
import test_locally.unit.GsonFactory;

import java.util.Arrays;

import static com.slack.api.model.block.Blocks.*;
import static com.slack.api.model.block.composition.BlockCompositions.asSectionFields;
import static com.slack.api.model.block.composition.BlockCompositions.plainText;
import static com.slack.api.model.block.element.BlockElements.checkboxes;
import static com.slack.api.model.block.element.BlockElements.conversationsSelect;
import static com.slack.api.model.view.Views.view;
import static com.slack.api.model.view.Views.viewSubmit;
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*;

public class BlockKitTest {

    @Test
    public void parseInputOnes() {
        String json = "{blocks: [{\n" +
                "  \"type\": \"input\",\n" +
                "  \"block_id\": \"input123\",\n" +
                "    \"label\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Label of input\"\n" +
                "    },\n" +
                "    \"hint\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Hint of input\"\n" +
                "    },\n" +
                "  \"element\": {\n" +
                "    \"type\": \"plain_text_input\",\n" +
                "    \"action_id\": \"plain_input\",\n" +
                "    \"placeholder\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Enter some plain text\"\n" +
                "    }\n" +
                "  }\n" +
                "}]}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        InputBlock inputBlock = (InputBlock) message.getBlocks().get(0);
        assertThat(inputBlock.getLabel(), is(notNullValue()));
        assertThat(inputBlock.getElement(), is(notNullValue()));
        assertThat(inputBlock.getHint(), is(notNullValue()));
    }

    @Test
    public void parseMarkdownBlock() {
        String blocks = "[{\n" +
                "  \"type\": \"markdown\",\n" +
                "  \"text\": \"**this is bold**\"\n" +
                "}]";
        String json = "{blocks: " + blocks + "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));
        MarkdownBlock markdownBlock = (MarkdownBlock) message.getBlocks().get(0);
        assertThat(markdownBlock.getText(), is("**this is bold**"));
    }

    @Test
    public void parseMultiSelectOnes() {
        String blocks = "[\n" +
                "    {\n" +
                "        \"type\": \"section\",\n" +
                "        \"block_id\": \"section678\",\n" +
                "        \"text\": {\n" +
                "            \"type\": \"mrkdwn\",\n" +
                "            \"text\": \"Pick items from the list\"\n" +
                "        },\n" +
                "        \"accessory\": {\n" +
                "            \"action_id\": \"text1234\",\n" +
                "            \"type\": \"multi_static_select\",\n" +
                "            \"placeholder\": {\n" +
                "                \"type\": \"plain_text\",\n" +
                "                \"text\": \"Select items\"\n" +
                "            },\n" +
                "            \"options\": [\n" +
                "                {\n" +
                "                    \"text\": {\n" +
                "                        \"type\": \"plain_text\",\n" +
                "                        \"text\": \"*this is plain_text text*\"\n" +
                "                    },\n" +
                "                    \"value\": \"value-0\"\n" +
                "                },\n" +
                "                {\n" +
                "                    \"text\": {\n" +
                "                        \"type\": \"plain_text\",\n" +
                "                        \"text\": \"*this is plain_text text*\"\n" +
                "                    },\n" +
                "                    \"value\": \"value-1\"\n" +
                "                },\n" +
                "                {\n" +
                "                    \"text\": {\n" +
                "                        \"type\": \"plain_text\",\n" +
                "                        \"text\": \"*this is plain_text text*\"\n" +
                "                    },\n" +
                "                    \"value\": \"value-2\"\n" +
                "                }\n" +
                "            ]\n" +
                "        }\n" +
                "    },\n" +
                "    {\n" +
                "        \"type\": \"section\",\n" +
                "        \"block_id\": \"section678\",\n" +
                "        \"text\": {\n" +
                "            \"type\": \"mrkdwn\",\n" +
                "            \"text\": \"Pick items from the list\"\n" +
                "        },\n" +
                "        \"accessory\": {\n" +
                "            \"action_id\": \"text1234\",\n" +
                "            \"type\": \"multi_external_select\",\n" +
                "            \"placeholder\": {\n" +
                "                \"type\": \"plain_text\",\n" +
                "                \"text\": \"Select items\"\n" +
                "      },\n" +
                "      \"min_query_length\": 3\n" +
                "        }\n" +
                "    }," +
                "    {\n" +
                "        \"type\": \"section\",\n" +
                "        \"block_id\": \"section678\",\n" +
                "        \"text\": {\n" +
                "            \"type\": \"mrkdwn\",\n" +
                "            \"text\": \"Pick users from the list\"\n" +
                "        },\n" +
                "        \"accessory\": {\n" +
                "            \"action_id\": \"text1234\",\n" +
                "            \"type\": \"multi_users_select\",\n" +
                "            \"placeholder\": {\n" +
                "                \"type\": \"plain_text\",\n" +
                "                \"text\": \"Select users\"\n" +
                "      }\n" +
                "        }\n" +
                "    }," +
                "    {\n" +
                "        \"type\": \"section\",\n" +
                "        \"block_id\": \"section678\",\n" +
                "        \"text\": {\n" +
                "            \"type\": \"mrkdwn\",\n" +
                "            \"text\": \"Pick conversations from the list\"\n" +
                "        },\n" +
                "        \"accessory\": {\n" +
                "            \"action_id\": \"text1234\",\n" +
                "            \"type\": \"multi_conversations_select\",\n" +
                "            \"placeholder\": {\n" +
                "                \"type\": \"plain_text\",\n" +
                "                \"text\": \"Select conversations\"\n" +
                "      }\n" +
                "        }\n" +
                "    }," +
                "    {\n" +
                "        \"type\": \"section\",\n" +
                "        \"block_id\": \"section678\",\n" +
                "        \"text\": {\n" +
                "            \"type\": \"mrkdwn\",\n" +
                "            \"text\": \"Pick channels from the list\"\n" +
                "        },\n" +
                "        \"accessory\": {\n" +
                "            \"action_id\": \"text1234\",\n" +
                "            \"type\": \"multi_channels_select\",\n" +
                "            \"placeholder\": {\n" +
                "                \"type\": \"plain_text\",\n" +
                "                \"text\": \"Select channels\"\n" +
                "      }\n" +
                "        }\n" +
                "    }" +
                "]";
        String json = "{blocks: " + blocks + "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(5));
    }

    @Test
    public void parseRichTextOnes() {
        // https://docs.slack.dev/changelog/2019/09/01/what-they-see-is-what-you-get-and-more-and-less
        String json = "{\n" +
                "  \"client_msg_id\": \"70c82df9-9db9-48b0-bf4e-9c43db3ed097\",\n" +
                "  \"type\": \"message\",\n" +
                "  \"text\": \"This is a *rich text *message that uses _italics and _~strikethrough ~and looks :sparkles: _*fabulous*_ :sparkles:\",\n" +
                "  \"user\": \"U0JD3BPNC\",\n" +
                "  \"ts\": \"1565629075.001000\",\n" +
                "  \"team\": \"T0JD3BPMW\",\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"hUBz\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"This is a \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"rich text \",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"message that uses \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"italics and \",\n" +
                "              \"style\": {\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"strikethrough \",\n" +
                "              \"style\": {\n" +
                "                \"strike\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"and looks \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"emoji\",\n" +
                "              \"name\": \"sparkles\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \" \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"fabulous\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \" \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"emoji\",\n" +
                "              \"name\": \"sparkles\"\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(view.getBlocks().size(), is(1));

        RichTextBlock richTextBlock = (RichTextBlock) view.getBlocks().get(0);
        assertThat(richTextBlock.getElements().size(), is(1));

        RichTextSectionElement richTextSection = (RichTextSectionElement) richTextBlock.getElements().get(0);
        assertThat(richTextSection.getElements().size(), is(11));

        RichTextSectionElement.Text text = (RichTextSectionElement.Text) richTextSection.getElements().get(1);
        assertThat(text.getType(), is("text"));
        assertThat(text.getText(), is("rich text "));
        assertThat(text.getStyle().isBold(), is(true));
        assertThat(text.getStyle().isItalic(), is(false));
        assertThat(text.getStyle().isStrike(), is(false));
        assertThat(text.getStyle().isUnderline(), is(false));
    }

    @Test
    public void parseRichTextOnes2() {
        // https://docs.slack.dev/changelog/2019/09/01/what-they-see-is-what-you-get-and-more-and-less
        String json = "{\n" +
                "  \"client_msg_id\": \"0e7bdef4-27a9-4bfa-bf16-c65683ff382b\",\n" +
                "  \"type\": \"message\",\n" +
                "  \"text\": \"dummy\"," +
                "  \"user\": \"W12345678\",\n" +
                "  \"ts\": \"1573737632.000800\",\n" +
                "  \"team\": \"T12345678\",\n" +
                "  \"edited\": {\n" +
                "    \"user\": \"W12345678\",\n" +
                "    \"ts\": \"1573737939.000000\"\n" +
                "  },\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"BMpCU\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"broadcast\",\n" +
                "              \"range\": \"channel\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \" test a\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"aaa\",\n" +
                "              \"style\": {\n" +
                "                \"strike\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"channel\",\n" +
                "              \"channel_id\": \"C123456678\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\ntest\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"link\",\n" +
                "              \"url\": \"http://www.example.com\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"user\",\n" +
                "              \"user_id\": \"W12345678\"\n" +
                "            }\n" +
                "          ]\n" +
                "        }" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";

        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(view.getBlocks().size(), is(1));
        RichTextBlock block = (RichTextBlock) view.getBlocks().get(0);
        assertThat(block.getElements().size(), is(1));
    }

    @Test
    public void parseRichTextOnes3() {
        // https://docs.slack.dev/changelog/2019/09/01/what-they-see-is-what-you-get-and-more-and-less
        String json = "{\n" +
                "  \"client_msg_id\": \"0e7bdef4-27a9-4bfa-bf16-c65683ff382b\",\n" +
                "  \"type\": \"message\",\n" +
                "  \"text\": \"@channel test a~aa~\\n#platform-feedback\\ntest\\nhttp://www.example.com\\n@kaz\\n\\n• test\\n• aaaa\\n\\n\\n1. foo\\n2. bar\\n3. baz\\n\\n\\n> something important\\n\\n\\n/`/`/`package example\\n\\nclass Foo/`/`/`\\n\\n*bold* something _italic_\",\n" +
                "  \"user\": \"W12345678\",\n" +
                "  \"ts\": \"1573737632.000800\",\n" +
                "  \"team\": \"T5J4Q04QG\",\n" +
                "  \"edited\": {\n" +
                "    \"user\": \"W12345678\",\n" +
                "    \"ts\": \"1573776943.000000\"\n" +
                "  },\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"nZTe+\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"user\",\n" +
                "              \"user_id\": \"W12345678\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\"\n" +
                "            }\n" +
                "          ]\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"test\"\n" +
                "                }\n" +
                "              ]\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"aaaa\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"bullet\",\n" +
                "          \"indent\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\"\n" +
                "            }\n" +
                "          ]\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"foo\"\n" +
                "                }\n" +
                "              ]\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"bar\"\n" +
                "                }\n" +
                "              ]\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"baz\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"ordered\",\n" +
                "          \"indent\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_quote\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"something important\"\n" +
                "            }\n" +
                "          ]\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_preformatted\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"package example\\n\\nclass Foo\"\n" +
                "            }\n" +
                "          ]\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"bold\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \" something \"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"italic\",\n" +
                "              \"style\": {\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";

        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(view.getBlocks().size(), is(1));
        RichTextBlock block = (RichTextBlock) view.getBlocks().get(0);
        assertThat(block.getElements().size(), is(7));
    }

    @Test
    public void parseRichTextOnes4() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"UXJk\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"1\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"bullet\",\n" +
                "          \"indent\": 0,\n" +
                "          \"border\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"11\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"bullet\",\n" +
                "          \"indent\": 1,\n" +
                "          \"border\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"111\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"bullet\",\n" +
                "          \"indent\": 2,\n" +
                "          \"border\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"1\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"ordered\",\n" +
                "          \"indent\": 0,\n" +
                "          \"border\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"11\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"ordered\",\n" +
                "          \"indent\": 1,\n" +
                "          \"border\": 0\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"rich_text_list\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"rich_text_section\",\n" +
                "              \"elements\": [\n" +
                "                {\n" +
                "                  \"type\": \"text\",\n" +
                "                  \"text\": \"111\"\n" +
                "                }\n" +
                "              ]\n" +
                "            }\n" +
                "          ],\n" +
                "          \"style\": \"ordered\",\n" +
                "          \"indent\": 2,\n" +
                "          \"border\": 0\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";

        // verify if Gson can parse the JSON data
        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(view.getBlocks().size(), is(1));
    }

    @Test
    public void parseRichTextOnes5() {
        // https://docs.slack.dev/changelog/2019/09/01/what-they-see-is-what-you-get-and-more-and-less
        String json = "{\n" +
                "  \"user\": \"U111\",\n" +
                "  \"type\": \"message\",\n" +
                "  \"ts\": \"1761165621.982069\",\n" +
                "  \"client_msg_id\": \"d0b7fc31-7456-4e54-9094-b5b1833fca8c\",\n" +
                "  \"text\": \"this is underline\",\n" +
                "  \"team\": \"T111\",\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"sfvOa\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"this is underline\",\n" +
                "              \"style\": {\n" +
                "                \"underline\": true\n" +
                "              }\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";

        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(view.getBlocks().size(), is(1));

        RichTextBlock richTextBlock = (RichTextBlock) view.getBlocks().get(0);
        assertThat(richTextBlock.getElements().size(), is(1));

        RichTextSectionElement richTextSection = (RichTextSectionElement) richTextBlock.getElements().get(0);
        assertThat(richTextSection.getElements().size(), is(1));

        RichTextSectionElement.Text text = (RichTextSectionElement.Text) richTextSection.getElements().get(0);
        assertThat(text.getType(), is("text"));
        assertThat(text.getText(), is("this is underline"));
        assertThat(text.getStyle().isBold(), is(false));
        assertThat(text.getStyle().isItalic(), is(false));
        assertThat(text.getStyle().isStrike(), is(false));
        assertThat(text.getStyle().isUnderline(), is(true));
    }

    @Test
    public void parseRadioButtons() {
        String json = "{" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"section\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Check out these rad radio buttons\"\n" +
                "      },\n" +
                "      \"accessory\": {\n" +
                "        \"type\": \"radio_buttons\",\n" +
                "        \"action_id\": \"this_is_an_action_id\",\n" +
                "        \"initial_option\": {\n" +
                "          \"value\": \"A1\",\n" +
                "          \"text\": {\n" +
                "            \"type\": \"plain_text\",\n" +
                "            \"text\": \"Radio 1\"\n" +
                "          }\n" +
                "        },\n" +
                "        \"options\": [\n" +
                "          {\n" +
                "            \"value\": \"A1\",\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"Radio 1\"\n" +
                "            }\n" +
                "          },\n" +
                "          {\n" +
                "            \"value\": \"A2\",\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"Radio 2\"\n" +
                "            }\n" +
                "          }\n" +
                "        ]\n" +
                "      }\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        SectionBlock block = (SectionBlock) message.getBlocks().get(0);
        RadioButtonsElement radioButtons = (RadioButtonsElement) block.getAccessory();
        assertThat(radioButtons.getActionId(), is("this_is_an_action_id"));
    }

    @Test
    public void rich_text_color_code() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"d77H\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"Hello\\n\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"color\",\n" +
                "              \"value\": \"#FFFFFF\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"\\n\\n\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"emoji\",\n" +
                "              \"name\": \"wave\"\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        RichTextBlock b = (RichTextBlock) message.getBlocks().get(0);
        RichTextSectionElement elm = (RichTextSectionElement) b.getElements().get(0);
        RichTextSectionElement.Color c = (RichTextSectionElement.Color) elm.getElements().get(1);
        assertThat(c.getType(), is(RichTextSectionElement.Color.TYPE));
        assertThat(c.getValue(), is("#FFFFFF"));

    }

    String unknownRichElementJson = "{\n" +
            "  \"blocks\": [\n" +
            "    {\n" +
            "      \"type\": \"rich_text\",\n" +
            "      \"block_id\": \"d77H\",\n" +
            "      \"elements\": [\n" +
            "        {\n" +
            "          \"type\": \"rich_text_section\",\n" +
            "          \"elements\": [\n" +
            "            {\n" +
            "              \"type\": \"text\",\n" +
            "              \"text\": \"Hello\\n\\n\"\n" +
            "            },\n" +
            "            {\n" +
            "              \"type\": \"unknown_type\"\n" +
            "            }\n" +
            "          ]\n" +
            "        }\n" +
            "      ]\n" +
            "    }\n" +
            "  ]\n" +
            "}";

    @Test
    public void rich_text_default_behavior_with_unknown() {
        Message message = GsonFactory.createSnakeCase().fromJson(unknownRichElementJson, Message.class);
        assertThat(message, is(notNullValue()));
        RichTextBlock b = (RichTextBlock) message.getBlocks().get(0);
        RichTextSectionElement elm = (RichTextSectionElement) b.getElements().get(0);
        RichTextUnknownElement c = (RichTextUnknownElement) elm.getElements().get(1);
        assertThat(c.getType(), is("unknown_type"));
    }

    @Test
    public void rich_text_fail_on_unknown() {
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(unknownRichElementJson, Message.class);
            fail("throwing JsonParseException is expected here");
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unknown RichTextSectionElement type: unknown_type"));
        }
    }

    @Test
    public void richText_emoji_with_style() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"UiW\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"This is a text part.\"\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"emoji\",\n" +
                "              \"name\": \"house\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true\n," +
                "                \"strike\": true" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"link\",\n" +
                "              \"url\": \"https://medium.com/slack-developer-blog\",\n" +
                "              \"text\": \"Slack Platform Blog\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true\n," +
                "                \"strike\": true" +
                "              }\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
    }

    String unknownBlocksJson = "{blocks: [{\n" +
            "  \"type\": \"unknown_block\",\n" +
            "  \"block_id\": \"input123\",\n" +
            "    \"label\": {\n" +
            "        \"type\": \"plain_text\",\n" +
            "        \"text\": \"Label of input\"\n" +
            "    },\n" +
            "  \"element\": {\n" +
            "    \"type\": \"unknown_element\",\n" +
            "    \"action_id\": \"plain_input\",\n" +
            "    \"placeholder\": {\n" +
            "      \"type\": \"plain_text\",\n" +
            "      \"text\": \"Enter some plain text\"\n" +
            "    }\n" +
            "  }\n" +
            "}]}";

    @Test
    public void parse_unknown_blocks() {
        Message message = GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(false)
                .fromJson(unknownBlocksJson, Message.class);
        assertThat(message, is(notNullValue()));
    }

    @Test
    public void parse_fail_on_unknown_blocks() {
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(unknownBlocksJson, Message.class);
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unsupported layout block type: unknown_block"));
        }
    }

    String unknownBlockElementsJson = "{blocks: [{\n" +
            "  \"type\": \"input\",\n" +
            "  \"block_id\": \"input123\",\n" +
            "    \"label\": {\n" +
            "        \"type\": \"plain_text\",\n" +
            "        \"text\": \"Label of input\"\n" +
            "    },\n" +
            "  \"element\": {\n" +
            "    \"type\": \"unknown_element\",\n" +
            "    \"action_id\": \"plain_input\",\n" +
            "    \"placeholder\": {\n" +
            "      \"type\": \"plain_text\",\n" +
            "      \"text\": \"Enter some plain text\"\n" +
            "    }\n" +
            "  }\n" +
            "}]}";

    @Test
    public void parse_unknown_block_elements() {
        Message message = GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(false)
                .fromJson(unknownBlockElementsJson, Message.class);
        assertThat(message, is(notNullValue()));
    }

    @Test
    public void parse_fail_on_unknown_block_elements() {
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(unknownBlockElementsJson, Message.class);
            fail();
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unknown block element type: unknown_element"));
        }
    }

    String unknownContextBlockElementsJson = "{blocks: [{\n" +
            "  \"type\": \"context\",\n" +
            "  \"elements\": [\n" +
            "    {\n" +
            "      \"type\": \"image\",\n" +
            "      \"image_url\": \"https://image.freepik.com/free-photo/red-drawing-pin_1156-445.jpg\",\n" +
            "      \"alt_text\": \"images\"\n" +
            "    },\n" +
            "    {\n" +
            "      \"type\": \"unknown_element\",\n" +
            "      \"text\": \"something\"\n" +
            "    }\n" +
            "  ]\n" +
            "}]}";

    @Test
    public void parse_unknown_context_block_elements() {
        Message message = GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(false)
                .fromJson(unknownContextBlockElementsJson, Message.class);
        assertThat(message, is(notNullValue()));
    }

    @Test
    public void parse_fail_on_unknown_context_block_elements() {
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(unknownContextBlockElementsJson, Message.class);
            fail();
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unknown context block element type: unknown_element"));
        }
    }

    String unknownTextObjectsJson = "{blocks: [{\n" +
            "  \"type\": \"section\",\n" +
            "  \"text\": {\n" +
            "    \"type\": \"unknown_text\",\n" +
            "    \"text\": \"This is a section block with a button.\"\n" +
            "  },\n" +
            "  \"accessory\": {\n" +
            "    \"type\": \"button\",\n" +
            "    \"text\": {\n" +
            "      \"type\": \"plain_text\",\n" +
            "      \"text\": \"Click Me\"\n" +
            "    },\n" +
            "    \"value\": \"click_me_123\",\n" +
            "    \"action_id\": \"button\"\n" +
            "  }\n" +
            "}]}";

    @Test
    public void parse_unknown_text_objects() {
        Message message = GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(false)
                .fromJson(unknownTextObjectsJson, Message.class);
        assertThat(message, is(notNullValue()));
    }

    @Test
    public void parse_fail_on_unknown_text_objects() {
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(unknownTextObjectsJson, Message.class);
            fail();
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unknown text object type: unknown_text"));
        }
    }

    String unknownTextObjectsInInputBlocksJson = "{blocks: [{\n" +
            "  \"type\": \"input\",\n" +
            "  \"block_id\": \"input123\",\n" +
            "  \"label\": {\n" +
            "    \"type\": \"plain_text2\",\n" +
            "    \"text\": \"Label of input\"\n" +
            "  },\n" +
            "  \"element\": {\n" +
            "    \"type\": \"plain_text_input\",\n" +
            "    \"action_id\": \"plain_input\",\n" +
            "    \"placeholder\": {\n" +
            "      \"type\": \"plain_text2\",\n" +
            "      \"text\": \"Enter some plain text\"\n" +
            "    }\n" +
            "  }\n" +
            "}]}";

    @Test
    public void parse_unknown_text_objects_input() {
        Message message = GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(false)
                .fromJson(unknownTextObjectsInInputBlocksJson, Message.class);
        assertThat(message, is(notNullValue()));
    }

    @Test
    public void parse_never_fails_on_unknown_text_objects_input() {
        // never fails - invalid types are just skipped
        GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                .fromJson(unknownTextObjectsInInputBlocksJson, Message.class);
    }

    @Test
    public void parseCheckboxes() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"input\",\n" +
                "      \"element\": {\n" +
                "        \"type\": \"checkboxes\",\n" +
                "        \"action_id\": \"input-action-id\",\n" +
                "        \"options\": [\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"*this is plain_text text*\",\n" +
                "              \"emoji\": true\n" +
                "            },\n" +
                "            \"value\": \"value-0\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"*this is plain_text text*\",\n" +
                "              \"emoji\": true\n" +
                "            },\n" +
                "            \"value\": \"value-1\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"*this is plain_text text*\",\n" +
                "              \"emoji\": true\n" +
                "            },\n" +
                "            \"value\": \"value-2\"\n" +
                "          }\n" +
                "        ]\n" +
                "      },\n" +
                "      \"label\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Label\",\n" +
                "        \"emoji\": true\n" +
                "      }\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"section\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"mrkdwn\",\n" +
                "        \"text\": \"This is a section block with checkboxes.\"\n" +
                "      },\n" +
                "      \"accessory\": {\n" +
                "        \"type\": \"checkboxes\",\n" +
                "        \"action_id\": \"section-action-id\",\n" +
                "        \"options\": [\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"description\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"value\": \"value-0\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"description\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"value\": \"value-1\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"text\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"description\": {\n" +
                "              \"type\": \"mrkdwn\",\n" +
                "              \"text\": \"*this is mrkdwn text*\"\n" +
                "            },\n" +
                "            \"value\": \"value-2\"\n" +
                "          }\n" +
                "        ]\n" +
                "      }\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));

        InputBlock input = (InputBlock) message.getBlocks().get(0);
        CheckboxesElement checkboxes1 = (CheckboxesElement) input.getElement();
        assertThat(checkboxes1.getActionId(), is("input-action-id"));

        SectionBlock block = (SectionBlock) message.getBlocks().get(1);
        CheckboxesElement checkboxes2 = (CheckboxesElement) block.getAccessory();
        assertThat(checkboxes2.getActionId(), is("section-action-id"));
    }

    @Test
    public void confirm_style() {
        String json = "{\n" +
                "  \"title\": {\n" +
                "    \"type\": \"plain_text\",\n" +
                "    \"text\": \"Are you sure?\"\n" +
                "  },\n" +
                "  \"text\": {\n" +
                "    \"type\": \"mrkdwn\",\n" +
                "    \"text\": \"Wouldn't you prefer a good game of _chess_?\"\n" +
                "  },\n" +
                "  \"confirm\": {\n" +
                "    \"type\": \"plain_text\",\n" +
                "    \"text\": \"Do it\"\n" +
                "  },\n" +
                "  \"deny\": {\n" +
                "    \"type\": \"plain_text\",\n" +
                "    \"text\": \"Stop, I've changed my mind!\"\n" +
                "  },\n" +
                "  \"style\":\"primary\"\n" +
                "}";

        ConfirmationDialogObject obj = GsonFactory.createSnakeCase().fromJson(json, ConfirmationDialogObject.class);
        assertThat(obj, is(notNullValue()));
        assertThat(obj.getStyle(), is("primary"));
    }

    @Test
    public void parseHeader() {
        String json = "{\n" +
                "  \"blocks\": [{\n" +
                "    \"type\": \"header\",\n" +
                "    \"block_id\": \"b\",\n" +
                "    \"text\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Budget Performance\"\n" +
                "    }\n" +
                "  }]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));

        HeaderBlock header = (HeaderBlock) message.getBlocks().get(0);
        assertThat(header.getBlockId(), is("b"));
        assertThat(header.getText().getType(), is("plain_text"));
        assertThat(header.getText().getText(), is("Budget Performance"));
    }

    @Test
    public void parseCallBlock() {
        String json = "{\n" +
                "  \"type\": \"call\",\n" +
                "  \"call_id\": \"R111\",\n" +
                "  \"block_id\": \"hH9L\",\n" +
                "  \"api_decoration_available\": false,\n" +
                "  \"call\": {\n" +
                "    \"v1\": {\n" +
                "      \"id\": \"R111\",\n" +
                "      \"app_id\": \"A111\",\n" +
                "      \"app_icon_urls\": {\n" +
                "        \"image_32\": \"https://avatars.slack-edge.com/xxx_32.jpg\",\n" +
                "        \"image_36\": \"https://avatars.slack-edge.com/xxx_36.jpg\",\n" +
                "        \"image_48\": \"https://avatars.slack-edge.com/xxx_48.jpg\",\n" +
                "        \"image_64\": \"https://avatars.slack-edge.com/xxx_64.jpg\",\n" +
                "        \"image_72\": \"https://avatars.slack-edge.com/xxx_72.jpg\",\n" +
                "        \"image_96\": \"https://avatars.slack-edge.com/xxx_96.jpg\",\n" +
                "        \"image_128\": \"https://avatars.slack-edge.com/xxx_128.jpg\",\n" +
                "        \"image_192\": \"https://avatars.slack-edge.com/xxx_192.jpg\",\n" +
                "        \"image_512\": \"https://avatars.slack-edge.com/xxx_512.jpg\",\n" +
                "        \"image_1024\": \"https://avatars.slack-edge.com/xxx_1024.jpg\",\n" +
                "        \"image_original\": \"https://avatars.slack-edge.com/xxx_original.jpg\"\n" +
                "      },\n" +
                "      \"date_start\": 1596711312,\n" +
                "      \"active_participants\": [\n" +
                "        {\n" +
                "          \"external_id\": \"anon-111\",\n" +
                "          \"avatar_url\": \"https://assets.brandfolder.com/xxx/slackbot.png\",\n" +
                "          \"display_name\": \"anonymous user 1\"\n" +
                "        },\n" +
                "        {\n" +
                "          \"slack_id\": \"USLACKBOT\"\n" +
                "        }\n" +
                "      ],\n" +
                "      \"all_participants\": [\n" +
                "        {\n" +
                "          \"external_id\": \"anon-111\",\n" +
                "          \"avatar_url\": \"https://assets.brandfolder.com/xxx/slackbot.png\",\n" +
                "          \"display_name\": \"anonymous user 1\"\n" +
                "        },\n" +
                "        {\n" +
                "          \"slack_id\": \"USLACKBOT\"\n" +
                "        }\n" +
                "      ],\n" +
                "      \"display_id\": \"ext-display-id-111\",\n" +
                "      \"join_url\": \"https://www.example.com/calls-test\",\n" +
                "      \"desktop_app_join_url\": \"https://www.example.com/calls-test\",\n" +
                "      \"name\": \"Test call\",\n" +
                "      \"created_by\": \"U111\",\n" +
                "      \"date_end\": 0,\n" +
                "      \"channels\": [\n" +
                "        \"C03E94MKU\"\n" +
                "      ],\n" +
                "      \"is_dm_call\": false,\n" +
                "      \"was_rejected\": false,\n" +
                "      \"was_missed\": false,\n" +
                "      \"was_accepted\": false,\n" +
                "      \"has_ended\": false\n" +
                "    },\n" +
                "    \"media_backend_type\": \"platform_call\",\n" +
                "    \"unknown_one_in_the_future\": 123\n" +
                "  }\n" +
                "}\n";
        Gson prodGson = GsonFactory.createSnakeCase(false, false);
        CallBlock block = prodGson.fromJson(json, CallBlock.class);
        assertThat(block, is(notNullValue()));
    }

    @Test
    public void parseContextActionsBlock() {
            String json = "{\n" +
            "      \"type\": \"context_actions\",\n" +
            "      \"elements\": [\n" +
            "        {\n" +
            "          \"type\": \"feedback_buttons\",\n" +
            "          \"action_id\": \"feedback\",\n" +
            "          \"positive_button\": {\n" +
            "            \"text\": {\n" +
            "              \"type\": \"plain_text\",\n" +
            "              \"text\": \"Good Response\",\n" +
            "              \"emoji\": true\n" +
            "            },\n" +
            "            \"accessibility_label\": \"Submit positive feedback on this response\",\n" +
            "            \"value\": \"good-feedback\"\n" +
            "          },\n" +
            "          \"negative_button\": {\n" +
            "            \"text\": {\n" +
            "              \"type\": \"plain_text\",\n" +
            "              \"text\": \"Bad Response\",\n" +
            "              \"emoji\": true\n" +
            "            },\n" +
            "            \"accessibility_label\": \"Submit negative feedback on this response\",\n" +
            "            \"value\": \"bad-feedback\"\n" +
            "          }\n" +
            "        },\n" +
            "        {\n" +
            "          \"type\": \"icon_button\",\n" +
            "          \"icon\": \"trash\",\n" +
            "          \"text\": {\n" +
            "            \"type\": \"plain_text\",\n" +
            "            \"text\": \"Remove\"\n" +
            "          },\n" +
            "          \"confirm\": {\n" +
            "            \"title\": {\n" +
            "              \"type\": \"plain_text\",\n" +
            "              \"text\": \"Oops\"\n" +
            "            },\n" +
            "            \"text\": {\n" +
            "              \"type\": \"plain_text\",\n" +
            "              \"text\": \"This response might've been just alright...\"\n" +
            "            },\n" +
            "            \"style\": \"danger\"\n" +
            "          },\n" +
            "          \"visible_to_user_ids\": [\"USLACKBOT\", \"U0123456789\"]\n" +
            "        }\n" +
            "      ]\n" +
            "}";
        ContextActionsBlock block = GsonFactory.createSnakeCase().fromJson(json, ContextActionsBlock.class);
        assertNotNull(block);
        assertEquals("context_actions", block.getType());
        assertEquals(2, block.getElements().size());
        FeedbackButtonsElement buttons = (FeedbackButtonsElement) block.getElements().get(0);
        assertEquals("feedback", buttons.getActionId());
        assertEquals("good-feedback", buttons.getPositiveButton().getValue());
        assertEquals("bad-feedback", buttons.getNegativeButton().getValue());
        assertEquals("Good Response", buttons.getPositiveButton().getText().getText());
        assertEquals("Bad Response", buttons.getNegativeButton().getText().getText());
        IconButtonElement iconButton = (IconButtonElement) block.getElements().get(1);
        assertEquals("trash", iconButton.getIcon());
        assertEquals("Remove", iconButton.getText().getText());
        assertEquals("Oops", iconButton.getConfirm().getTitle().getText());
        assertEquals("This response might've been just alright...", iconButton.getConfirm().getText().getText());
        assertEquals("danger", iconButton.getConfirm().getStyle());
        assertEquals(Arrays.asList("USLACKBOT", "U0123456789"), iconButton.getVisibleToUserIds());
    }

    @Test
    public void parseButtonWithAgentPrompt() {
        String json = "{\n" +
                "  \"type\": \"actions\",\n" +
                "  \"elements\": [\n" +
                "    {\n" +
                "      \"type\": \"button\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Summarize with Slackbot\"\n" +
                "      },\n" +
                "      \"action_id\": \"summarize_incident\",\n" +
                "      \"agent_prompt\": \"Summarize this incident and suggest next steps.\",\n" +
                "      \"agent_prompt_display\": \"Summarize this incident\",\n" +
                "      \"visible_to_user_ids\": [\"U123456\"]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        ActionsBlock block = GsonFactory.createSnakeCase().fromJson(json, ActionsBlock.class);
        ButtonElement button = (ButtonElement) block.getElements().get(0);
        assertEquals("Summarize this incident and suggest next steps.", button.getAgentPrompt());
        assertEquals("Summarize this incident", button.getAgentPromptDisplay());
        assertEquals(Arrays.asList("U123456"), button.getVisibleToUserIds());
        String serialized = GsonFactory.createSnakeCase().toJson(block);
        assertThat(serialized, containsString("\"agent_prompt\":\"Summarize this incident and suggest next steps.\""));
        assertThat(serialized, containsString("\"agent_prompt_display\":\"Summarize this incident\""));
        assertThat(serialized, containsString("\"visible_to_user_ids\":[\"U123456\"]"));
    }

    String richTextSkinTone = "{ \"blocks\": [\n" +
            "  {\n" +
            "    \"type\": \"rich_text\",\n" +
            "    \"block_id\": \"b123\",\n" +
            "    \"elements\": [\n" +
            "      {\n" +
            "        \"type\": \"rich_text_section\",\n" +
            "        \"elements\": [\n" +
            "          {\n" +
            "            \"type\": \"text\",\n" +
            "            \"text\": \"Hello\"\n" +
            "          },\n" +
            "          {\n" +
            "            \"type\": \"emoji\",\n" +
            "            \"name\": \"wave\",\n" +
            "            \"skin_tone\": 3\n" +
            "          },\n" +
            "          {\n" +
            "            \"type\": \"emoji\",\n" +
            "            \"name\": \"rocket\"\n" +
            "          }\n" +
            "        ]\n" +
            "      }\n" +
            "    ]\n" +
            "  }\n" +
            "]}";

    @Test
    public void testRichTextSkinToneEmoji() {
        Message message = GsonFactory.createSnakeCase().fromJson(richTextSkinTone, Message.class);
        assertNotNull(message);
    }

    @Test
    public void testSection() {
        assertThat(section(s -> s.blockId("block-id").fields(asSectionFields(plainText("foo")))), is(notNullValue()));
    }

    @Test
    public void testCheckboxes() {
        assertThat(section(s -> s.blockId("block-id").accessory(checkboxes(c -> c.actionId("foo")))), is(notNullValue()));
        assertThat(input(i -> i.element(checkboxes(c -> c.actionId("foo")))), is(notNullValue()));
    }

    @Test
    public void testConversationsFilter() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"input\",\n" +
                "    \"element\": {\n" +
                "      \"type\": \"conversations_select\",\n" +
                "      \"placeholder\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Select a conversation\",\n" +
                "        \"emoji\": true\n" +
                "      },\n" +
                "      \"filter\": {\n" +
                "        \"include\": [\n" +
                "          \"public\",\n" +
                "          \"mpim\"\n" +
                "        ],\n" +
                "        \"exclude_bot_users\": true\n" +
                "      }\n" +
                "    },\n" +
                "    \"label\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                "      \"emoji\": true\n" +
                "    }\n" +
                "  }\n" +
                "]}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertNotNull(message);
        assertEquals(1, message.getBlocks().size());
        InputBlock block = (InputBlock) message.getBlocks().get(0);
        ConversationsSelectElement element = (ConversationsSelectElement) block.getElement();
        assertEquals(Arrays.asList("public", "mpim"), element.getFilter().getInclude());
        assertTrue(element.getFilter().getExcludeBotUsers());
        assertNull(element.getFilter().getExcludeExternalSharedChannels());
    }

    @Test
    public void testConversationsFilter_multi() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"input\",\n" +
                "    \"element\": {\n" +
                "      \"type\": \"multi_conversations_select\",\n" +
                "      \"placeholder\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Select a conversation\",\n" +
                "        \"emoji\": true\n" +
                "      },\n" +
                "      \"filter\": {\n" +
                "        \"include\": [\n" +
                "          \"public\",\n" +
                "          \"mpim\"\n" +
                "        ],\n" +
                "        \"exclude_bot_users\": true\n" +
                "      }\n" +
                "    },\n" +
                "    \"label\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                "      \"emoji\": true\n" +
                "    }\n" +
                "  }\n" +
                "]}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertNotNull(message);
        assertEquals(1, message.getBlocks().size());
        InputBlock block = (InputBlock) message.getBlocks().get(0);
        MultiConversationsSelectElement element = (MultiConversationsSelectElement) block.getElement();
        assertEquals(Arrays.asList("public", "mpim"), element.getFilter().getInclude());
        assertTrue(element.getFilter().getExcludeBotUsers());
        assertNull(element.getFilter().getExcludeExternalSharedChannels());
    }

    @Test
    public void testResponseUrlEnabled_conversations() {
        {
            String json = "{\"blocks\":[\n" +
                    "  {\n" +
                    "    \"type\": \"input\",\n" +
                    "    \"element\": {\n" +
                    "      \"type\": \"conversations_select\",\n" +
                    "      \"placeholder\": {\n" +
                    "        \"type\": \"plain_text\",\n" +
                    "        \"text\": \"Select a conversation\",\n" +
                    "        \"emoji\": true\n" +
                    "      },\n" +
                    "      \"response_url_enabled\": true\n" +
                    "    },\n" +
                    "    \"label\": {\n" +
                    "      \"type\": \"plain_text\",\n" +
                    "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                    "      \"emoji\": true\n" +
                    "    }\n" +
                    "  }\n" +
                    "]}";
            Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
            assertNotNull(message);
            assertEquals(1, message.getBlocks().size());
            InputBlock block = (InputBlock) message.getBlocks().get(0);
            ConversationsSelectElement element = (ConversationsSelectElement) block.getElement();
            assertTrue(element.getResponseUrlEnabled());
        }

        {
            String json = "{\"blocks\":[\n" +
                    "  {\n" +
                    "    \"type\": \"input\",\n" +
                    "    \"element\": {\n" +
                    "      \"type\": \"conversations_select\",\n" +
                    "      \"placeholder\": {\n" +
                    "        \"type\": \"plain_text\",\n" +
                    "        \"text\": \"Select a conversation\",\n" +
                    "        \"emoji\": true\n" +
                    "      }\n" +
                    "    },\n" +
                    "    \"label\": {\n" +
                    "      \"type\": \"plain_text\",\n" +
                    "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                    "      \"emoji\": true\n" +
                    "    },\n" +
                    "    \"hint\": {\n" +
                    "      \"type\": \"plain_text\",\n" +
                    "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                    "      \"emoji\": true\n" +
                    "    }\n" +
                    "  }\n" +
                    "]}";
            Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
            assertNotNull(message);
            assertEquals(1, message.getBlocks().size());
            InputBlock block = (InputBlock) message.getBlocks().get(0);
            ConversationsSelectElement element = (ConversationsSelectElement) block.getElement();
            assertNull(element.getResponseUrlEnabled());
        }
    }

    @Test
    public void testResponseUrlEnabled_channels() {
        {
            String json = "{\"blocks\":[\n" +
                    "  {\n" +
                    "    \"type\": \"input\",\n" +
                    "    \"element\": {\n" +
                    "      \"type\": \"channels_select\",\n" +
                    "      \"placeholder\": {\n" +
                    "        \"type\": \"plain_text\",\n" +
                    "        \"text\": \"Select a conversation\",\n" +
                    "        \"emoji\": true\n" +
                    "      },\n" +
                    "      \"response_url_enabled\": true\n" +
                    "    },\n" +
                    "    \"label\": {\n" +
                    "      \"type\": \"plain_text\",\n" +
                    "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                    "      \"emoji\": true\n" +
                    "    }\n" +
                    "  }\n" +
                    "]}";
            Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
            assertNotNull(message);
            assertEquals(1, message.getBlocks().size());
            InputBlock block = (InputBlock) message.getBlocks().get(0);
            ChannelsSelectElement element = (ChannelsSelectElement) block.getElement();
            assertTrue(element.getResponseUrlEnabled());
        }

        {
            String json = "{\"blocks\":[\n" +
                    "  {\n" +
                    "    \"type\": \"input\",\n" +
                    "    \"element\": {\n" +
                    "      \"type\": \"channels_select\",\n" +
                    "      \"placeholder\": {\n" +
                    "        \"type\": \"plain_text\",\n" +
                    "        \"text\": \"Select a conversation\",\n" +
                    "        \"emoji\": true\n" +
                    "      }\n" +
                    "    },\n" +
                    "    \"label\": {\n" +
                    "      \"type\": \"plain_text\",\n" +
                    "      \"text\": \"Choose the conversation to publish your result to:\",\n" +
                    "      \"emoji\": true\n" +
                    "    }\n" +
                    "  }\n" +
                    "]}";
            Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
            assertNotNull(message);
            assertEquals(1, message.getBlocks().size());
            InputBlock block = (InputBlock) message.getBlocks().get(0);
            ChannelsSelectElement element = (ChannelsSelectElement) block.getElement();
            assertNull(element.getResponseUrlEnabled());
        }
    }

    @Test
    public void defaultToCurrentConversation() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"section\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"mrkdwn\",\n" +
                "        \"text\": \"Test block with multi conversations select\"\n" +
                "      },\n" +
                "      \"accessory\": {\n" +
                "        \"type\": \"multi_conversations_select\",\n" +
                "        \"placeholder\": {\n" +
                "          \"type\": \"plain_text\",\n" +
                "          \"text\": \"Select conversations\",\n" +
                "          \"emoji\": true\n" +
                "        },\n" +
                "        \"default_to_current_conversation\": true\n" +
                "      }\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"section\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"mrkdwn\",\n" +
                "        \"text\": \"Test block with multi conversations select\"\n" +
                "      },\n" +
                "      \"accessory\": {\n" +
                "        \"type\": \"conversations_select\",\n" +
                "        \"placeholder\": {\n" +
                "          \"type\": \"plain_text\",\n" +
                "          \"text\": \"Select conversations\",\n" +
                "          \"emoji\": true\n" +
                "        },\n" +
                "        \"default_to_current_conversation\": true\n" +
                "      }\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertNotNull(message);
        assertEquals(2, message.getBlocks().size());
        SectionBlock section1 = (SectionBlock) message.getBlocks().get(0);
        MultiConversationsSelectElement elem1 = (MultiConversationsSelectElement) (section1).getAccessory();
        assertTrue(elem1.getDefaultToCurrentConversation());
        SectionBlock section2 = (SectionBlock) message.getBlocks().get(1);
        ConversationsSelectElement elem2 = (ConversationsSelectElement) (section2).getAccessory();
        assertTrue(elem2.getDefaultToCurrentConversation());
    }

    @Test
    public void codeInDocs() {
        View modalView = view(v -> v
                .type("modal")
                .callbackId("view-id")
                .submit(viewSubmit(vs -> vs.type("plain_text").text("Submit")))
                .blocks(asBlocks(
                        section(s -> s
                                .text(plainText("Conversation to post the result"))
                                .accessory(conversationsSelect(conv -> conv
                                        .actionId("a")
                                        .defaultToCurrentConversation(true)
                                        .responseUrlEnabled(true))
                                )
                        )
                )));
        assertNotNull(modalView);
    }

    @Test
    public void timePickerElement() {
        // https://docs.slack.dev/reference/block-kit/block-elements/time-picker-element
        String json = "{\n" +
                "  \"type\": \"section\",\n" +
                "  \"block_id\": \"section1234\",\n" +
                "  \"text\": {\n" +
                "    \"type\": \"mrkdwn\",\n" +
                "    \"text\": \"Pick a date for the deadline.\"\n" +
                "  },\n" +
                "  \"accessory\": {\n" +
                "    \"type\": \"timepicker\",\n" +
                "    \"action_id\": \"timepicker123\",\n" +
                "    \"initial_time\": \"11:40\",\n" +
                "    \"placeholder\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Select a time\"\n" +
                "    }\n" +
                "  }\n" +
                "}";
        Gson gson = GsonFactory.createSnakeCase();
        SectionBlock section = gson.fromJson(json, SectionBlock.class);
        assertThat(section.getBlockId(), is("section1234"));
        TimePickerElement accessory = (TimePickerElement) section.getAccessory();
        assertThat(accessory.getActionId(), is("timepicker123"));
        assertThat(accessory.getInitialTime(), is("11:40"));
        assertThat(accessory.getPlaceholder().getText(), is("Select a time"));
        assertThat(accessory.getConfirm(), is(nullValue()));

        String output = gson.toJson(section);
        assertThat(output, is("{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"Pick a date for the deadline.\"},\"block_id\":\"section1234\",\"accessory\":{\"type\":\"timepicker\",\"action_id\":\"timepicker123\",\"placeholder\":{\"type\":\"plain_text\",\"text\":\"Select a time\"},\"initial_time\":\"11:40\"}}"));
    }

    @Test
    public void focusOnLoad() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"input\",\n" +
                "    \"element\": {\n" +
                "      \"type\": \"conversations_select\",\n" +
                "      \"placeholder\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Select a conversation\"\n" +
                "      },\n" +
                "      \"focus_on_load\": true\n" +
                "    },\n" +
                "    \"label\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Choose the conversation to publish your result to:\"\n" +
                "    }\n" +
                "  }\n" +
                "]}";
        View view = GsonFactory.createSnakeCase().fromJson(json, View.class);
        assertNotNull(view);
        assertEquals(1, view.getBlocks().size());
        InputBlock block = (InputBlock) view.getBlocks().get(0);
        ConversationsSelectElement element = (ConversationsSelectElement) block.getElement();
        assertTrue(element.getFocusOnLoad());
    }

    @Test
    public void noFocusOnLoad() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"input\",\n" +
                "    \"element\": {\n" +
                "      \"type\": \"conversations_select\",\n" +
                "      \"placeholder\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Select a conversation\"\n" +
                "      }\n" +
                "    },\n" +
                "    \"label\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Choose the conversation to publish your result to:\"\n" +
                "    }\n" +
                "  }\n" +
                "]}";
        View view = GsonFactory.createSnakeCase().fromJson(json, View.class);
        assertNotNull(view);
        assertEquals(1, view.getBlocks().size());
        InputBlock block = (InputBlock) view.getBlocks().get(0);
        ConversationsSelectElement element = (ConversationsSelectElement) block.getElement();
        assertNull(element.getFocusOnLoad());
    }

    @Test
    public void parseVideoBlocks() {
        // https://docs.slack.dev/reference/block-kit/blocks/video-block
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"video\",\n" +
                "      \"block_id\": \"bid\",\n" +
                "      \"title\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"How to use Slack.\",\n" +
                "        \"emoji\": true\n" +
                "      },\n" +
                "      \"title_url\": \"https://www.youtube.com/watch?v=RRxQQxiM7AA\",\n" +
                "      \"description\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"Slack is a new way to communicate with your team. It's faster, better organized and more secure than email.\",\n" +
                "        \"emoji\": true\n" +
                "      },\n" +
                "      \"video_url\": \"https://www.youtube.com/embed/RRxQQxiM7AA?feature=oembed&autoplay=1\",\n" +
                "      \"alt_text\": \"How to use Slack?\",\n" +
                "      \"thumbnail_url\": \"https://i.ytimg.com/vi/RRxQQxiM7AA/hqdefault.jpg\",\n" +
                "      \"author_name\": \"Arcado Buendia\",\n" +
                "      \"provider_name\": \"YouTube\",\n" +
                "      \"provider_icon_url\": \"https://a.slack-edge.com/80588/img/unfurl_icons/youtube.png\"\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        View view = GsonFactory.createSnakeCase().fromJson(json, View.class);
        assertNotNull(view);
        assertEquals(1, view.getBlocks().size());
        VideoBlock block = (VideoBlock) view.getBlocks().get(0);
        assertEquals("bid", block.getBlockId());
        assertEquals("https://www.youtube.com/embed/RRxQQxiM7AA?feature=oembed&autoplay=1", block.getVideoUrl());
    }

    @Test
    public void parseAlertBlocks() {
        // https://docs.slack.dev/reference/block-kit/blocks/alert-block
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"alert\",\n" +
                "      \"block_id\": \"alert-1\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"mrkdwn\",\n" +
                "        \"text\": \"Something went *wrong*.\"\n" +
                "      },\n" +
                "      \"level\": \"error\"\n" +
                "    },\n" +
                "    {\n" +
                "      \"type\": \"alert\",\n" +
                "      \"text\": {\n" +
                "        \"type\": \"plain_text\",\n" +
                "        \"text\": \"A plain text alert with no markup.\"\n" +
                "      }\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        View view = GsonFactory.createSnakeCase().fromJson(json, View.class);
        assertNotNull(view);
        assertEquals(2, view.getBlocks().size());

        AlertBlock errorAlert = (AlertBlock) view.getBlocks().get(0);
        assertEquals("alert", errorAlert.getType());
        assertEquals("alert-1", errorAlert.getBlockId());
        assertEquals("error", errorAlert.getLevel());
        assertEquals("mrkdwn", errorAlert.getText().getType());
        assertEquals("Something went *wrong*.", errorAlert.getText().getText());

        AlertBlock defaultAlert = (AlertBlock) view.getBlocks().get(1);
        assertEquals("plain_text", defaultAlert.getText().getType());
        assertNull(defaultAlert.getLevel());
        assertNull(defaultAlert.getBlockId());
    }

    @Test
    public void buildAlertBlock() {
        AlertBlock block = alert(a -> a
                .blockId("alert-1")
                .level("info")
                .text(plainText("Heads up!")));
        assertNotNull(block);
        assertEquals("alert", block.getType());

        Gson gson = GsonFactory.createSnakeCase();
        String output = gson.toJson(block);
        AlertBlock parsed = gson.fromJson(output, AlertBlock.class);
        assertEquals("alert-1", parsed.getBlockId());
        assertEquals("info", parsed.getLevel());
        assertEquals("Heads up!", parsed.getText().getText());
    }

    @Test
    public void parseLinkTriggerMessages() {
        // https://tools.slack.dev/deno-slack-sdk/
        String json = "{\n" +
                "  \"client_msg_id\": \"xxx\",\n" +
                "  \"type\": \"message\",\n" +
                "  \"text\": \"https://slack.com/shortcuts/Ft111/xxx\",\n" +
                "  \"user\": \"U111\",\n" +
                "  \"ts\": \"1663233138.852489\",\n" +
                "  \"team\": \"T111\",\n" +
                "  \"attachments\": [\n" +
                "    {\n" +
                "      \"fallback\": \"Workflow\",\n" +
                "      \"from_url\": \"https://slack.com/shortcuts/Ft111/xxx\",\n" +
                "      \"blocks\": [\n" +
                "        {\n" +
                "          \"block_id\": \"shortcut-block\",\n" +
                "          \"type\": \"share_shortcut\",\n" +
                "          \"function_trigger_id\": \"Ft111\",\n" +
                "          \"app_id\": \"A111\",\n" +
                "          \"is_workflow_app\": false,\n" +
                "          \"app_collaborators\": [\n" +
                "            \"U111\"\n" +
                "          ],\n" +
                "          \"button_label\": \"\",\n" +
                "          \"title\": \"Sample trigger\",\n" +
                "          \"description\": \"A sample trigger\",\n" +
                "          \"bot_user_id\": \"U111\",\n" +
                "          \"url\": \"https://slack.com/shortcuts/Ft111/xxx\"\n" +
                "        }\n" +
                "      ],\n" +
                "      \"id\": 1,\n" +
                "      \"original_url\": \"https://slack.com/shortcuts/Ft111/xxx\"\n" +
                "    }\n" +
                "  ],\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"block_id\": \"JZy\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"link\",\n" +
                "              \"url\": \"https://slack.com/shortcuts/Ft111/xxx\"\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message view = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertNotNull(view);
        assertEquals(1, view.getAttachments().get(0).getBlocks().size());
        assertEquals(1, view.getBlocks().size());
    }


    @Test
    public void parseRichTextElements() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"date\",\n" +
                "              \"timestamp\": 1234567890,\n" +
                "              \"format\": \"{date_num}\",\n" +
                "              \"style\": {\n" +
                "                \"code\": false,\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"link\",\n" +
                "              \"url\": \"https://slack.com/\",\n" +
                "              \"text\": \"with a link\",\n" +
                "              \"unsafe\": true,\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"code\": false,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"italic\": true,\n" +
                "                \"strike\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"we are near the end\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"code\": false,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"emoji\",\n" +
                "              \"name\": \"basketball\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"color\",\n" +
                "              \"value\": \"#F405B3\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"italic\": true,\n" +
                "                \"strike\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"team\",\n" +
                "              \"team_id\": \"T03E94MJU\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"user\",\n" +
                "              \"user_id\": \"U03E94MK0\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": true,\n" +
                "                \"client_highlight\": true,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"usergroup\",\n" +
                "              \"usergroup_id\": \"SKAQ0Q1NW\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": false,\n" +
                "                \"client_highlight\": false,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"broadcast\",\n" +
                "              \"range\": \"here\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": false,\n" +
                "                \"client_highlight\": false,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            },\n" +
                "            {\n" +
                "              \"type\": \"channel\",\n" +
                "              \"channel_id\": \"CHE2DUW5V\",\n" +
                "              \"style\": {\n" +
                "                \"bold\": true,\n" +
                "                \"highlight\": false,\n" +
                "                \"client_highlight\": false,\n" +
                "                \"unlink\": true,\n" +
                "                \"italic\": true\n" +
                "              }\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));
        RichTextSectionElement section = (RichTextSectionElement) ((RichTextBlock) message.getBlocks().get(0)).getElements().get(0);
        assertThat(section.getElements().size(), is(10));
    }

    @Test
    public void parseCardBlock() {
        // https://docs.slack.dev/reference/block-kit/blocks/card-block
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"card\",\n" +
                "    \"block_id\": \"card1\",\n" +
                "    \"icon\": {\n" +
                "      \"type\": \"image\",\n" +
                "      \"image_url\": \"https://picsum.photos/36/36\",\n" +
                "      \"alt_text\": \"Icon\"\n" +
                "    },\n" +
                "    \"hero_image\": {\n" +
                "      \"type\": \"image\",\n" +
                "      \"image_url\": \"https://picsum.photos/400/300\",\n" +
                "      \"alt_text\": \"Sample hero image\"\n" +
                "    },\n" +
                "    \"title\": {\n" +
                "      \"type\": \"mrkdwn\",\n" +
                "      \"text\": \"Lumon Industries\"\n" +
                "    },\n" +
                "    \"subtitle\": {\n" +
                "      \"type\": \"mrkdwn\",\n" +
                "      \"text\": \"Committed to work-life balance\"\n" +
                "    },\n" +
                "    \"body\": {\n" +
                "      \"type\": \"mrkdwn\",\n" +
                "      \"text\": \"Please enjoy each card equally.\"\n" +
                "    },\n" +
                "    \"actions\": [\n" +
                "      {\n" +
                "        \"type\": \"button\",\n" +
                "        \"text\": {\n" +
                "          \"type\": \"plain_text\",\n" +
                "          \"text\": \"Action Button\"\n" +
                "        },\n" +
                "        \"action_id\": \"button_action\"\n" +
                "      }\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        CardBlock card = (CardBlock) message.getBlocks().get(0);
        assertThat(card.getType(), is("card"));
        assertThat(card.getBlockId(), is("card1"));
        assertThat(card.getIcon().getImageUrl(), is("https://picsum.photos/36/36"));
        assertThat(card.getIcon().getAltText(), is("Icon"));
        assertThat(card.getHeroImage().getImageUrl(), is("https://picsum.photos/400/300"));
        assertThat(card.getHeroImage().getAltText(), is("Sample hero image"));
        assertThat(card.getTitle().getType(), is("mrkdwn"));
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) card.getTitle()).getText(), is("Lumon Industries"));
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) card.getSubtitle()).getText(), is("Committed to work-life balance"));
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) card.getBody()).getText(), is("Please enjoy each card equally."));
        assertThat(card.getActions().size(), is(1));
        ButtonElement button = (ButtonElement) card.getActions().get(0);
        assertThat(button.getActionId(), is("button_action"));
        assertThat(button.getText().getText(), is("Action Button"));

        // Round-trip back to JSON and ensure the card survives serialization.
        Message roundTrip = gson.fromJson(gson.toJson(message), Message.class);
        CardBlock reparsed = (CardBlock) roundTrip.getBlocks().get(0);
        assertThat(reparsed.getBlockId(), is("card1"));
        assertThat(reparsed.getActions().size(), is(1));
        assertThat(((ButtonElement) reparsed.getActions().get(0)).getActionId(), is("button_action"));
    }

    @Test
    public void buildCardBlock() {
        CardBlock card = card(c -> c
                .blockId("card2")
                .title(com.slack.api.model.block.composition.MarkdownTextObject.builder().text("Title").build())
                .body(com.slack.api.model.block.composition.PlainTextObject.builder().text("Body").build())
                .actions(Arrays.asList(
                        ButtonElement.builder()
                                .actionId("a")
                                .text(plainText("Click"))
                                .build()
                ))
        );
        assertThat(card.getType(), is("card"));
        assertThat(card.getBlockId(), is("card2"));
        Gson gson = GsonFactory.createSnakeCase();
        Message message = new Message();
        message.setBlocks(asBlocks(card));
        Message reparsed = gson.fromJson(gson.toJson(message), Message.class);
        CardBlock parsedCard = (CardBlock) reparsed.getBlocks().get(0);
        assertThat(parsedCard.getBlockId(), is("card2"));
        assertThat(parsedCard.getActions().size(), is(1));
    }

    @Test
    public void parseCarouselBlock() {
        // https://docs.slack.dev/reference/block-kit/blocks/carousel-block
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"carousel\",\n" +
                "    \"block_id\": \"carousel1\",\n" +
                "    \"elements\": [\n" +
                "      {\n" +
                "        \"type\": \"card\",\n" +
                "        \"block_id\": \"card1\",\n" +
                "        \"title\": {\n" +
                "          \"type\": \"mrkdwn\",\n" +
                "          \"text\": \"First card\"\n" +
                "        },\n" +
                "        \"body\": {\n" +
                "          \"type\": \"mrkdwn\",\n" +
                "          \"text\": \"Body of the first card.\"\n" +
                "        },\n" +
                "        \"hero_image\": {\n" +
                "          \"type\": \"image\",\n" +
                "          \"image_url\": \"https://picsum.photos/400/300\",\n" +
                "          \"alt_text\": \"hero\"\n" +
                "        },\n" +
                "        \"actions\": [\n" +
                "          {\n" +
                "            \"type\": \"button\",\n" +
                "            \"text\": {\n" +
                "              \"type\": \"plain_text\",\n" +
                "              \"text\": \"Open\"\n" +
                "            },\n" +
                "            \"action_id\": \"open\"\n" +
                "          }\n" +
                "        ]\n" +
                "      },\n" +
                "      {\n" +
                "        \"type\": \"card\",\n" +
                "        \"title\": {\n" +
                "          \"type\": \"mrkdwn\",\n" +
                "          \"text\": \"Second card\"\n" +
                "        }\n" +
                "      }\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        CarouselBlock carousel = (CarouselBlock) message.getBlocks().get(0);
        assertThat(carousel.getType(), is("carousel"));
        assertThat(carousel.getBlockId(), is("carousel1"));
        assertThat(carousel.getElements().size(), is(2));

        CardBlock firstCard = carousel.getElements().get(0);
        assertThat(firstCard.getType(), is("card"));
        assertThat(firstCard.getBlockId(), is("card1"));
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) firstCard.getTitle()).getText(), is("First card"));
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) firstCard.getBody()).getText(), is("Body of the first card."));
        assertThat(firstCard.getHeroImage().getImageUrl(), is("https://picsum.photos/400/300"));
        assertThat(firstCard.getActions().size(), is(1));
        ButtonElement button = (ButtonElement) firstCard.getActions().get(0);
        assertThat(button.getActionId(), is("open"));

        CardBlock secondCard = carousel.getElements().get(1);
        assertThat(((com.slack.api.model.block.composition.MarkdownTextObject) secondCard.getTitle()).getText(), is("Second card"));
        assertThat(secondCard.getBlockId(), is(nullValue()));

        // Round-trip back to JSON and ensure the carousel survives serialization.
        Message roundTrip = gson.fromJson(gson.toJson(message), Message.class);
        CarouselBlock reparsed = (CarouselBlock) roundTrip.getBlocks().get(0);
        assertThat(reparsed.getBlockId(), is("carousel1"));
        assertThat(reparsed.getElements().size(), is(2));
        assertThat(reparsed.getElements().get(0).getType(), is("card"));
    }

    @Test
    public void parseContainerBlock() {
        // https://docs.slack.dev/reference/block-kit/blocks/container-block
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"container\",\n" +
                "    \"block_id\": \"container1\",\n" +
                "    \"title\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"Container Title\"\n" +
                "    },\n" +
                "    \"subtitle\": {\n" +
                "      \"type\": \"mrkdwn\",\n" +
                "      \"text\": \"*Bold* subtitle\"\n" +
                "    },\n" +
                "    \"width\": \"wide\",\n" +
                "    \"is_collapsible\": true,\n" +
                "    \"default_collapsed\": false,\n" +
                "    \"icon\": {\n" +
                "      \"type\": \"image\",\n" +
                "      \"image_url\": \"https://example.com/icon.png\",\n" +
                "      \"alt_text\": \"icon\"\n" +
                "    },\n" +
                "    \"child_blocks\": [\n" +
                "      {\n" +
                "        \"type\": \"section\",\n" +
                "        \"text\": {\n" +
                "          \"type\": \"mrkdwn\",\n" +
                "          \"text\": \"Section inside container.\"\n" +
                "        }\n" +
                "      },\n" +
                "      {\n" +
                "        \"type\": \"divider\"\n" +
                "      }\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        ContainerBlock container = (ContainerBlock) message.getBlocks().get(0);
        assertThat(container.getType(), is("container"));
        assertThat(container.getBlockId(), is("container1"));
        assertThat(container.getTitle().getType(), is("plain_text"));
        assertThat(container.getTitle().getText(), is("Container Title"));
        assertThat(container.getSubtitle().getType(), is("mrkdwn"));
        assertThat(container.getWidth(), is("wide"));
        assertThat(container.getIsCollapsible(), is(true));
        assertThat(container.getDefaultCollapsed(), is(false));
        assertThat(container.getIcon().getImageUrl(), is("https://example.com/icon.png"));
        assertThat(container.getChildBlocks().size(), is(2));
        assertThat(container.getChildBlocks().get(0), is(instanceOf(SectionBlock.class)));
        assertThat(container.getChildBlocks().get(1), is(instanceOf(DividerBlock.class)));

        // Round-trip
        Message roundTrip = gson.fromJson(gson.toJson(message), Message.class);
        ContainerBlock reparsed = (ContainerBlock) roundTrip.getBlocks().get(0);
        assertThat(reparsed.getBlockId(), is("container1"));
        assertThat(reparsed.getChildBlocks().size(), is(2));
    }

    @Test
    public void parseContainerBlockWithRichTextTitle() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"container\",\n" +
                "    \"rich_text_title\": {\n" +
                "      \"type\": \"rich_text\",\n" +
                "      \"elements\": [\n" +
                "        {\n" +
                "          \"type\": \"rich_text_section\",\n" +
                "          \"elements\": [\n" +
                "            {\n" +
                "              \"type\": \"text\",\n" +
                "              \"text\": \"Rich Title\"\n" +
                "            }\n" +
                "          ]\n" +
                "        }\n" +
                "      ]\n" +
                "    },\n" +
                "    \"child_blocks\": [\n" +
                "      {\n" +
                "        \"type\": \"divider\"\n" +
                "      }\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        ContainerBlock container = (ContainerBlock) message.getBlocks().get(0);
        assertThat(container.getRichTextTitle(), is(notNullValue()));
        assertThat(container.getRichTextTitle().getType(), is("rich_text"));
        assertThat(container.getRichTextTitle().getElements().size(), is(1));
        assertThat(container.getTitle(), is(nullValue()));
    }

    @Test
    public void parseContainerBlockWithHeaderDivider() {
        String json = "{\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"container\",\n" +
                "    \"title\": {\n" +
                "      \"type\": \"plain_text\",\n" +
                "      \"text\": \"With divider\"\n" +
                "    },\n" +
                "    \"has_header_divider\": true,\n" +
                "    \"child_blocks\": [\n" +
                "      {\n" +
                "        \"type\": \"divider\"\n" +
                "      }\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        ContainerBlock container = (ContainerBlock) message.getBlocks().get(0);
        assertThat(container.getHasHeaderDivider(), is(true));
        assertThat(container.getIsCollapsible(), is(nullValue()));
    }

    @Test
    public void buildContainerBlock() {
        ContainerBlock container = container(c -> c
                .blockId("container1")
                .title(com.slack.api.model.block.composition.PlainTextObject.builder().text("Title").build())
                .width("wide")
                .isCollapsible(true)
                .childBlocks(Arrays.asList(
                        divider()
                ))
        );
        assertThat(container.getType(), is("container"));
        assertThat(container.getBlockId(), is("container1"));

        Gson gson = GsonFactory.createSnakeCase();
        Message message = new Message();
        message.setBlocks(asBlocks(container));
        Message reparsed = gson.fromJson(gson.toJson(message), Message.class);
        ContainerBlock parsedContainer = (ContainerBlock) reparsed.getBlocks().get(0);
        assertThat(parsedContainer.getBlockId(), is("container1"));
        assertThat(parsedContainer.getWidth(), is("wide"));
        assertThat(parsedContainer.getIsCollapsible(), is(true));
        assertThat(parsedContainer.getChildBlocks().size(), is(1));
    }

    @Test
    public void buildCarouselBlock() {
        CarouselBlock carousel = carousel(c -> c
                .blockId("carousel1")
                .elements(Arrays.asList(
                        card(card -> card
                                .blockId("card1")
                                .title(com.slack.api.model.block.composition.MarkdownTextObject.builder().text("Promo").build())
                                .body(com.slack.api.model.block.composition.PlainTextObject.builder().text("Check this out").build())
                                .actions(Arrays.asList(
                                        ButtonElement.builder()
                                                .actionId("open")
                                                .text(plainText("Open"))
                                                .build()
                                ))),
                        card(card -> card
                                .title(com.slack.api.model.block.composition.MarkdownTextObject.builder().text("Second").build()))
                ))
        );
        assertThat(carousel.getType(), is("carousel"));
        assertThat(carousel.getElements().size(), is(2));

        Gson gson = GsonFactory.createSnakeCase();
        Message message = new Message();
        message.setBlocks(asBlocks(carousel));
        Message reparsed = gson.fromJson(gson.toJson(message), Message.class);
        CarouselBlock parsedCarousel = (CarouselBlock) reparsed.getBlocks().get(0);
        assertThat(parsedCarousel.getBlockId(), is("carousel1"));
        assertThat(parsedCarousel.getElements().size(), is(2));
        assertThat(parsedCarousel.getElements().get(0).getType(), is("card"));
        assertThat(parsedCarousel.getElements().get(0).getBlockId(), is("card1"));
        assertThat(parsedCarousel.getElements().get(0).getActions().size(), is(1));
    }

    @Test
    public void parseDataTableBlock() {
        // https://docs.slack.dev/reference/block-kit/blocks/data-table-block
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"data_table\",\n" +
                "      \"block_id\": \"bid\",\n" +
                "      \"caption\": \"Quarterly results\",\n" +
                "      \"page_size\": 10,\n" +
                "      \"row_header_column_index\": 0,\n" +
                "      \"rows\": [\n" +
                "        [\n" +
                "          { \"type\": \"raw_text\", \"text\": \"Team\" },\n" +
                "          { \"type\": \"raw_text\", \"text\": \"Revenue\" },\n" +
                "          { \"type\": \"raw_text\", \"text\": \"Action\" }\n" +
                "        ],\n" +
                "        [\n" +
                "          {\n" +
                "            \"type\": \"rich_text\",\n" +
                "            \"elements\": [\n" +
                "              {\n" +
                "                \"type\": \"rich_text_section\",\n" +
                "                \"elements\": [ { \"type\": \"text\", \"text\": \"Platform\" } ]\n" +
                "              }\n" +
                "            ]\n" +
                "          },\n" +
                "          { \"type\": \"raw_number\", \"value\": 1234.5, \"text\": \"$1,234.50\" },\n" +
                "          {\n" +
                "            \"type\": \"action_cell\",\n" +
                "            \"element\": {\n" +
                "              \"type\": \"button\",\n" +
                "              \"text\": { \"type\": \"plain_text\", \"text\": \"Mark done\" },\n" +
                "              \"action_id\": \"mark_done\",\n" +
                "              \"value\": \"task_123\"\n" +
                "            },\n" +
                "            \"fallback\": { \"type\": \"raw_text\", \"text\": \"Open\" }\n" +
                "          }\n" +
                "        ]\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Message message = GsonFactory.createSnakeCase().fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        DataTableBlock block = (DataTableBlock) message.getBlocks().get(0);
        assertThat(block.getType(), is("data_table"));
        assertThat(block.getBlockId(), is("bid"));
        assertThat(block.getCaption(), is("Quarterly results"));
        assertThat(block.getPageSize(), is(10));
        assertThat(block.getRowHeaderColumnIndex(), is(0));
        assertThat(block.getRows().size(), is(2));

        RawTextObject header = (RawTextObject) block.getRows().get(0).get(0);
        assertThat(header.getType(), is("raw_text"));
        assertThat(header.getText(), is("Team"));

        TableCell richCell = block.getRows().get(1).get(0);
        assertTrue(richCell instanceof RichTextBlock);
        assertThat(richCell.getType(), is("rich_text"));

        RawNumberObject numberCell = (RawNumberObject) block.getRows().get(1).get(1);
        assertThat(numberCell.getType(), is("raw_number"));
        assertThat(numberCell.getValue(), is(1234.5));
        assertThat(numberCell.getText(), is("$1,234.50"));

        ActionCellObject actionCell = (ActionCellObject) block.getRows().get(1).get(2);
        assertThat(actionCell.getType(), is("action_cell"));
        assertThat(actionCell.getElement().getActionId(), is("mark_done"));
        assertThat(actionCell.getElement().getValue(), is("task_123"));
        RawTextObject fallback = (RawTextObject) actionCell.getFallback();
        assertThat(fallback.getText(), is("Open"));
    }

    @Test
    public void buildDataTableBlock() {
        DataTableBlock block = dataTable(t -> t
                .blockId("bid")
                .caption("Quarterly results")
                .pageSize(10)
                .rowHeaderColumnIndex(0)
                .rows(Arrays.asList(
                        Arrays.asList(
                                RawTextObject.builder().text("Team").build(),
                                RawTextObject.builder().text("Revenue").build(),
                                RawTextObject.builder().text("Action").build()
                        ),
                        Arrays.asList(
                                RawTextObject.builder().text("Platform").build(),
                                RawNumberObject.builder().value(1234.5).text("$1,234.50").build(),
                                ActionCellObject.builder()
                                        .element(ButtonElement.builder()
                                                .text(plainText("Mark done"))
                                                .actionId("mark_done")
                                                .value("task_123")
                                                .build())
                                        .fallback(RawTextObject.builder().text("Open").build())
                                        .build()
                        )
                )));
        assertThat(block, is(notNullValue()));

        Gson gson = GsonFactory.createSnakeCase();
        String json = gson.toJson(block);
        DataTableBlock restored = (DataTableBlock) gson.fromJson(json, LayoutBlock.class);
        assertThat(restored.getType(), is("data_table"));
        assertThat(restored.getCaption(), is("Quarterly results"));
        assertThat(restored.getPageSize(), is(10));
        assertThat(restored.getRows().size(), is(2));
        RawNumberObject numberCell = (RawNumberObject) restored.getRows().get(1).get(1);
        assertThat(numberCell.getValue(), is(1234.5));
        ActionCellObject actionCell = (ActionCellObject) restored.getRows().get(1).get(2);
        assertThat(actionCell.getElement().getActionId(), is("mark_done"));
        assertThat(((RawTextObject) actionCell.getFallback()).getText(), is("Open"));
    }

    @Test
    public void data_table_default_behavior_with_unknown_cell() {
        String json = "{\n" +
                "  \"type\": \"data_table\",\n" +
                "  \"rows\": [\n" +
                "    [\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Task\" },\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Owner\" }\n" +
                "    ],\n" +
                "    [\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Write docs\" },\n" +
                "      { \"type\": \"unknown_cell_in_the_future\", \"user_id\": \"U123456\" }\n" +
                "    ]\n" +
                "  ]\n" +
                "}";
        Gson prodGson = GsonFactory.createSnakeCase(false, false);
        DataTableBlock block = (DataTableBlock) prodGson.fromJson(json, LayoutBlock.class);
        assertThat(block.getRows().get(1).size(), is(2));
        TableCell cell = block.getRows().get(1).get(1);
        assertTrue(cell instanceof UnknownTableCell);
        assertThat(cell.getType(), is("unknown_cell_in_the_future"));
    }

    @Test
    public void data_table_fail_on_unknown_cell() {
        String json = "{\n" +
                "  \"type\": \"data_table\",\n" +
                "  \"rows\": [\n" +
                "    [\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Task\" },\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Owner\" }\n" +
                "    ],\n" +
                "    [\n" +
                "      { \"type\": \"raw_text\", \"text\": \"Write docs\" },\n" +
                "      { \"type\": \"unknown_cell_in_the_future\", \"user_id\": \"U123456\" }\n" +
                "    ]\n" +
                "  ]\n" +
                "}";
        try {
            GsonFactory.createSnakeCaseWithoutUnknownPropertyDetection(true)
                    .fromJson(json, LayoutBlock.class);
            fail("throwing JsonParseException is expected here");
        } catch (JsonParseException e) {
            assertThat(e.getMessage(), is("Unknown table cell type: unknown_cell_in_the_future"));
        }
    }

    @Test
    public void parseTaskCardBlock() {
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"task_card\",\n" +
                "      \"task_id\": \"task_1\",\n" +
                "      \"title\": \"Fetching weather data\",\n" +
                "      \"status\": \"in_progress\",\n" +
                "      \"output\": {\n" +
                "        \"type\": \"rich_text\",\n" +
                "        \"elements\": [\n" +
                "          {\n" +
                "            \"type\": \"rich_text_section\",\n" +
                "            \"elements\": [\n" +
                "              {\n" +
                "                \"type\": \"text\",\n" +
                "                \"text\": \"Found weather data for Chicago from 2 sources\"\n" +
                "              }\n" +
                "            ]\n" +
                "          }\n" +
                "        ]\n" +
                "      },\n" +
                "      \"sources\": [\n" +
                "        {\n" +
                "          \"type\": \"url\",\n" +
                "          \"url\": \"https://weather.com/\",\n" +
                "          \"text\": \"weather.com\"\n" +
                "        },\n" +
                "        {\n" +
                "          \"type\": \"url\",\n" +
                "          \"url\": \"https://www.accuweather.com/\",\n" +
                "          \"text\": \"accuweather.com\"\n" +
                "        }\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        TaskCardBlock taskCard = (TaskCardBlock) message.getBlocks().get(0);
        assertThat(taskCard.getType(), is("task_card"));
        assertThat(taskCard.getTaskId(), is("task_1"));
        assertThat(taskCard.getTitle(), is("Fetching weather data"));
        assertThat(taskCard.getStatus(), is("in_progress"));

        assertThat(taskCard.getOutput(), is(notNullValue()));
        assertThat(taskCard.getOutput().getType(), is("rich_text"));

        assertThat(taskCard.getSources().size(), is(2));
        assertThat(taskCard.getSources().get(0).getType(), is("url"));
        assertThat(taskCard.getSources().get(0).getUrl(), is("https://weather.com/"));
        assertThat(taskCard.getSources().get(0).getText(), is("weather.com"));
        assertThat(taskCard.getSources().get(1).getUrl(), is("https://www.accuweather.com/"));
        assertThat(taskCard.getSources().get(1).getText(), is("accuweather.com"));
    }

    @Test
    public void buildTaskCardBlock() {
        TaskCardBlock taskCard = Blocks.taskCard(t -> t
                .taskId("task_42")
                .title("Processing data")
                .status("in_progress")
                .sources(Arrays.asList(
                        UrlSourceElement.builder().url("https://example.com").text("example").build())));
        assertThat(taskCard, is(notNullValue()));
        assertThat(taskCard.getType(), is("task_card"));
        assertThat(taskCard.getTaskId(), is("task_42"));
        assertThat(taskCard.getTitle(), is("Processing data"));
        assertThat(taskCard.getStatus(), is("in_progress"));
        assertThat(taskCard.getSources().size(), is(1));
    }

    @Test
    public void parseAuthProviderBlock() {
        String json = "{\"type\":\"home\",\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"auth_provider\",\n" +
                "    \"block_id\": \"auth1\",\n" +
                "    \"value\": \"acme\",\n" +
                "    \"name\": {\"type\": \"plain_text\", \"text\": \"Acme\"},\n" +
                "    \"is_connected\": true,\n" +
                "    \"description\": {\"type\": \"plain_text\", \"text\": \"Search Acme docs\"},\n" +
                "    \"icon_url\": \"https://acme.example.com/icon.png\",\n" +
                "    \"auth_url\": \"https://acme.example.com/oauth\",\n" +
                "    \"disconnect_url\": \"https://acme.example.com/disconnect\",\n" +
                "    \"connected_identity\": {\"type\": \"plain_text\", \"text\": \"jane@acme.example.com\"},\n" +
                "    \"connected_context\": {\"type\": \"plain_text\", \"text\": \"Acme Corp\"},\n" +
                "    \"accessory\": {\n" +
                "      \"type\": \"overflow\",\n" +
                "      \"action_id\": \"acme_menu\",\n" +
                "      \"options\": [\n" +
                "        {\"text\": {\"type\": \"plain_text\", \"text\": \"Switch accounts\"}, \"value\": \"switch\"},\n" +
                "        {\"text\": {\"type\": \"plain_text\", \"text\": \"Disconnect\"}, \"value\": \"disconnect\"}\n" +
                "      ]\n" +
                "    },\n" +
                "    \"fallback\": [\n" +
                "      {\"type\": \"section\", \"text\": {\"type\": \"mrkdwn\", \"text\": \"Connected to Acme\"}}\n" +
                "    ]\n" +
                "  }\n" +
                "]}";
        Gson gson = GsonFactory.createSnakeCase();
        View view = gson.fromJson(json, View.class);
        assertThat(view.getBlocks().size(), is(1));

        AuthProviderBlock authProvider = (AuthProviderBlock) view.getBlocks().get(0);
        assertThat(authProvider.getType(), is("auth_provider"));
        assertThat(authProvider.getBlockId(), is("auth1"));
        assertThat(authProvider.getValue(), is("acme"));
        assertThat(authProvider.getName().getText(), is("Acme"));
        assertThat(authProvider.getIsConnected(), is(true));
        assertThat(authProvider.getDescription().getText(), is("Search Acme docs"));
        assertThat(authProvider.getIconUrl(), is("https://acme.example.com/icon.png"));
        assertThat(authProvider.getAuthUrl(), is("https://acme.example.com/oauth"));
        assertThat(authProvider.getDisconnectUrl(), is("https://acme.example.com/disconnect"));
        assertThat(authProvider.getConnectedIdentity().getText(), is("jane@acme.example.com"));
        assertThat(authProvider.getConnectedContext().getText(), is("Acme Corp"));
        assertThat(authProvider.getAccessory().getActionId(), is("acme_menu"));
        assertThat(authProvider.getAccessory().getOptions().size(), is(2));
        assertThat(authProvider.getFallback().size(), is(1));
        assertThat(authProvider.getFallback().get(0), is(instanceOf(SectionBlock.class)));

        View roundTrip = gson.fromJson(gson.toJson(view), View.class);
        assertThat(roundTrip.getBlocks().get(0), is(authProvider));
    }

    @Test
    public void parseAuthProviderBlockWithRequiredFieldsOnly() {
        String json = "{\"type\":\"home\",\"blocks\":[\n" +
                "  {\n" +
                "    \"type\": \"auth_provider\",\n" +
                "    \"value\": \"acme\",\n" +
                "    \"name\": {\"type\": \"plain_text\", \"text\": \"Acme\"},\n" +
                "    \"is_connected\": false\n" +
                "  }\n" +
                "]}";
        View view = GsonFactory.createSnakeCase().fromJson(json, View.class);

        AuthProviderBlock authProvider = (AuthProviderBlock) view.getBlocks().get(0);
        assertThat(authProvider.getIsConnected(), is(false));
        assertThat(authProvider.getAccessory(), is(nullValue()));
        assertThat(authProvider.getFallback(), is(nullValue()));
    }

    @Test
    public void buildAuthProviderBlock() {
        AuthProviderBlock authProvider = authProvider(a -> a
                .value("acme")
                .name(plainText("Acme"))
                .isConnected(false)
                .authUrl("https://acme.example.com/oauth"));

        String json = GsonFactory.createSnakeCase().toJson(authProvider);
        assertThat(json, is("{\"type\":\"auth_provider\",\"value\":\"acme\"," +
                "\"name\":{\"type\":\"plain_text\",\"text\":\"Acme\"}," +
                "\"is_connected\":false,\"auth_url\":\"https://acme.example.com/oauth\"}"));
    }

    @Test
    public void parseTableBlock() {
        // https://docs.slack.dev/reference/block-kit/blocks/table-block
        String json = "{\n" +
                "  \"blocks\": [\n" +
                "    {\n" +
                "      \"type\": \"table\",\n" +
                "      \"column_settings\": [\n" +
                "        {\n" +
                "          \"is_wrapped\": true\n" +
                "        },\n" +
                "        {\n" +
                "          \"align\": \"right\"\n" +
                "        }\n" +
                "      ],\n" +
                "      \"rows\": [\n" +
                "        [\n" +
                "          {\n" +
                "            \"type\": \"raw_text\",\n" +
                "            \"text\": \"Header A\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"type\": \"raw_text\",\n" +
                "            \"text\": \"Header B\"\n" +
                "          }\n" +
                "        ],\n" +
                "        [\n" +
                "          {\n" +
                "            \"type\": \"raw_text\",\n" +
                "            \"text\": \"Data 1A\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"type\": \"rich_text\",\n" +
                "            \"elements\": [\n" +
                "              {\n" +
                "                \"type\": \"rich_text_section\",\n" +
                "                \"elements\": [\n" +
                "                  {\n" +
                "                    \"text\": \"Data 1B\",\n" +
                "                    \"type\": \"link\",\n" +
                "                    \"url\": \"https://slack.com\"\n" +
                "                  }\n" +
                "                ]\n" +
                "              }\n" +
                "            ]\n" +
                "          }\n" +
                "        ],\n" +
                "        [\n" +
                "          {\n" +
                "            \"type\": \"raw_text\",\n" +
                "            \"text\": \"Data 2A\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"type\": \"rich_text\",\n" +
                "            \"elements\": [\n" +
                "              {\n" +
                "                \"type\": \"rich_text_section\",\n" +
                "                \"elements\": [\n" +
                "                  {\n" +
                "                    \"text\": \"Data 2B\",\n" +
                "                    \"type\": \"link\",\n" +
                "                    \"url\": \"https://slack.com\"\n" +
                "                  }\n" +
                "                ]\n" +
                "              }\n" +
                "            ]\n" +
                "          }\n" +
                "        ],\n" +
                "        [\n" +
                "          {\n" +
                "            \"type\": \"raw_text\",\n" +
                "            \"text\": \"Data 3A\"\n" +
                "          },\n" +
                "          {\n" +
                "            \"type\": \"raw_number\",\n" +
                "            \"value\": 400.5,\n" +
                "            \"text\": \"$400.50\"\n" +
                "          }\n" +
                "        ]\n" +
                "      ]\n" +
                "    }\n" +
                "  ]\n" +
                "}";
        Gson gson = GsonFactory.createSnakeCase();
        Message message = gson.fromJson(json, Message.class);
        assertThat(message, is(notNullValue()));
        assertThat(message.getBlocks().size(), is(1));

        TableBlock block = (TableBlock) message.getBlocks().get(0);
        assertThat(block.getType(), is("table"));
        assertThat(block.getColumnSettings().size(), is(2));
        assertThat(block.getColumnSettings().get(0).getAlign(), is(nullValue()));
        assertThat(block.getColumnSettings().get(0).getIsWrapped(), is(true));
        assertThat(block.getColumnSettings().get(1).getAlign(), is("right"));
        assertThat(block.getColumnSettings().get(1).getIsWrapped(), is(nullValue()));
        assertThat(block.getRows().size(), is(4));

        RawTextObject header = (RawTextObject) block.getRows().get(0).get(0);
        assertThat(header.getType(), is("raw_text"));
        assertThat(header.getText(), is("Header A"));

        RichTextBlock richCell = (RichTextBlock) block.getRows().get(1).get(1);
        assertThat(richCell.getType(), is("rich_text"));
        RichTextSectionElement section = (RichTextSectionElement) richCell.getElements().get(0);
        RichTextSectionElement.Link link = (RichTextSectionElement.Link) section.getElements().get(0);
        assertThat(link.getText(), is("Data 1B"));
        assertThat(link.getUrl(), is("https://slack.com"));

        RawNumberObject numberCell = (RawNumberObject) block.getRows().get(3).get(1);
        assertThat(numberCell.getType(), is("raw_number"));
        assertThat(numberCell.getValue(), is(400.5));
        assertThat(numberCell.getText(), is("$400.50"));

        assertThat(
                gson.toJsonTree(message.getBlocks()),
                is(JsonParser.parseString(json).getAsJsonObject().get("blocks")));
    }

    @Test
    public void buildTableBlock() {
        TableBlock block = table(t -> t
                .blockId("bid")
                .columnSettings(Arrays.asList(
                        TableBlock.ColumnSetting.builder().isWrapped(true).build(),
                        TableBlock.ColumnSetting.builder().align("right").build()
                ))
                .rows(Arrays.asList(
                        Arrays.asList(
                                RawTextObject.builder().text("Item").build(),
                                RawTextObject.builder().text("Cost").build()
                        ),
                        Arrays.asList(
                                RawTextObject.builder().text("Rent").build(),
                                RawNumberObject.builder().value(400.5).text("$400.50").build()
                        )
                )));
        assertThat(block, is(notNullValue()));

        Gson gson = GsonFactory.createSnakeCase();
        String json = gson.toJson(block);
        assertThat(json, is("{\"type\":\"table\"," +
                "\"rows\":[" +
                "[{\"type\":\"raw_text\",\"text\":\"Item\"},{\"type\":\"raw_text\",\"text\":\"Cost\"}]," +
                "[{\"type\":\"raw_text\",\"text\":\"Rent\"},{\"type\":\"raw_number\",\"value\":400.5,\"text\":\"$400.50\"}]" +
                "]," +
                "\"column_settings\":[{\"is_wrapped\":true},{\"align\":\"right\"}]," +
                "\"block_id\":\"bid\"}"));

        TableBlock restored = (TableBlock) gson.fromJson(json, LayoutBlock.class);
        assertThat(restored, is(block));
    }
}