fn parse_response(

        parts: ResponseAttributes<'_>,

    ) -> Result<Self::Response, ResponseParserError> {

        let parts: Vec<_> = parts.into();

        debug_assert!(parts.len() % 2 == 0);

        let mut messages = Vec::with_capacity(parts.len() / 2);

        for channel_message_pair in parts.chunks_exact(2) {

            let (ckey, cvalue) = channel_message_pair[0];

            let (mkey, mvalue) = channel_message_pair[1];

            debug_assert!(ckey == "channel");

            debug_assert!(mkey == "message");

            let channel = expect_property_type!(Some(cvalue), "channel", Text).to_string();

            let message = expect_property_type!(Some(mvalue), "message", Text).to_string();

            messages.push((channel, message));

        Ok(ReadMessagesResponse { messages })

    }

    fn test_parse_response() {

        let input = indoc! {"

            channel: channel1

            message: message1

            channel: channel2

            message: message2

            OK

        "};

        let result = ReadMessages::parse_raw_response(input);

        assert_eq!(

            result,

            Ok(ReadMessagesResponse {

                messages: vec![

                    ("channel1".to_string(), "message1".to_string()),

                    ("channel2".to_string(), "message2".to_string()),

                ]

            })

        );

    }