sheave_core/messages/
on_status.rs

1mod publishing_failure;
2
3use std::io::Result as IOResult;
4use crate::{
5    ByteBuffer,
6    Decoder,
7    Encoder,
8    messages::{
9        Channel,
10        ChunkData,
11        Command,
12        amf::v0::{
13            Object,
14            Null
15        },
16        headers::MessageType
17    }
18};
19pub use self::publishing_failure::*;
20
21/// The response message for Publish requests.
22#[derive(Debug, Clone, Default, PartialEq)]
23pub struct OnStatus(Object);
24
25impl OnStatus {
26    /// Constructs an OnStatus command.
27    pub fn new(info_object: Object) -> Self {
28        Self(info_object)
29    }
30
31    /// Gets the info object.
32    pub fn get_info_object(&self) -> &Object {
33        &self.0
34    }
35}
36
37impl From<OnStatus> for Object {
38    fn from(on_status: OnStatus) -> Self {
39        on_status.0
40    }
41}
42
43impl ChunkData for OnStatus {
44    const CHANNEL: Channel = Channel::System;
45    const MESSAGE_TYPE: MessageType = MessageType::Command;
46}
47
48impl Command for OnStatus {}
49
50impl Decoder<OnStatus> for ByteBuffer {
51    /// Decodes bytes into an OnStatus command.
52    ///
53    /// # Errors
54    ///
55    /// * [`InsufficientBufferLength`]
56    ///
57    /// When some field misses.
58    ///
59    /// * [`InconsistentMarker`]
60    ///
61    /// When some value is inconsistent with its marker.
62    ///
63    /// # Examples
64    ///
65    /// ```rust
66    /// use sheave_core::{
67    ///     ByteBuffer,
68    ///     Decoder,
69    ///     Encoder,
70    ///     messages::{
71    ///         OnStatus,
72    ///         amf::v0::{
73    ///             Object,
74    ///             Null
75    ///         }
76    ///     }
77    /// };
78    ///
79    /// let mut buffer = ByteBuffer::default();
80    /// buffer.encode(&Null);
81    /// buffer.encode(&Object::default());
82    /// assert!(Decoder::<OnStatus>::decode(&mut buffer).is_ok());
83    ///
84    /// let mut buffer = ByteBuffer::default();
85    /// assert!(Decoder::<OnStatus>::decode(&mut buffer).is_err())
86    /// ```
87    ///
88    /// [`InsufficientBufferLength`]: crate::byte_buffer::InsufficientBufferLength
89    /// [`InconsistentMarker`]: crate::messages::amf::InconsistentMarker
90    fn decode(&mut self) -> IOResult<OnStatus> {
91        Decoder::<Null>::decode(self)?;
92        let info_object: Object = self.decode()?;
93
94        Ok(OnStatus(info_object))
95    }
96}
97
98impl Encoder<OnStatus> for ByteBuffer {
99    /// Encodes an OnStatus command into bytes.
100    fn encode(&mut self, on_status: &OnStatus) {
101        self.encode(&Null);
102        self.encode(on_status.get_info_object());
103    }
104}
105
106#[cfg(test)]
107mod tests {
108    use crate::{
109        messages::amf::v0::AmfString,
110        object
111    };
112    use super::*;
113
114    #[test]
115    fn decode_on_status() {
116        let mut buffer = ByteBuffer::default();
117        buffer.encode(&Null);
118        buffer.encode(
119            &object!(
120                "level" => AmfString::from("status"),
121                "code" => AmfString::from("NetStream.Publish.Start"),
122                "description" => AmfString::new(format!("{} is now published", "filename")),
123                "details" => AmfString::from("filename")
124            )
125        );
126        let result: IOResult<OnStatus> = buffer.decode();
127        assert!(result.is_ok());
128        let actual = result.unwrap();
129        let expected = OnStatus::new(
130            object!(
131                "level" => AmfString::from("status"),
132                "code" => AmfString::from("NetStream.Publish.Start"),
133                "description" => AmfString::new(format!("{} is now published", "filename")),
134                "details" => AmfString::from("filename")
135            )
136        );
137        assert_eq!(expected, actual);
138    }
139
140    #[test]
141    fn encode_on_status() {
142        let mut buffer = ByteBuffer::default();
143        let expected_info_object = object!(
144            "level" => AmfString::from("status"),
145            "code" => AmfString::from("NetStream.Publish.Start"),
146            "description" => AmfString::new(format!("{} is now published", "filename")),
147            "details" => AmfString::from("filename")
148        );
149        buffer.encode(&OnStatus::new(expected_info_object.clone()));
150        Decoder::<Null>::decode(&mut buffer).unwrap();
151        let actual_info_object: Object = buffer.decode().unwrap();
152        assert_eq!(expected_info_object, actual_info_object)
153    }
154}