Add a PubSub module.

src/macros.rs

@@ -101,6 +101,38 @@ macro_rules! generate_attribute {
             }
         }
     );
+    ($elem:ident, $name:tt, bool) => (
+        #[derive(Debug, Clone, PartialEq)]
+        pub enum $elem {
+            /// True value, represented by either 'true' or '1'.
+            True,
+            /// False value, represented by either 'false' or '0'.
+            False,
+        }
+        impl ::std::str::FromStr for $elem {
+            type Err = ::error::Error;
+            fn from_str(s: &str) -> Result<Self, ::error::Error> {
+                Ok(match s {
+                    "true" | "1" => $elem::True,
+                    "false" | "0" => $elem::False,
+                    _ => return Err(::error::Error::ParseError(concat!("Unknown value for '", $name, "' attribute."))),
+                })
+            }
+        }
+        impl ::minidom::IntoAttributeValue for $elem {
+            fn into_attribute_value(self) -> Option<String> {
+                match self {
+                    $elem::True => Some(String::from("true")),
+                    $elem::False => None
+                }
+            }
+        }
+        impl ::std::default::Default for $elem {
+            fn default() -> $elem {
+                $elem::False
+            }
+        }
+    );
 }
 
 macro_rules! generate_element_enum {
@@ -392,6 +424,9 @@ macro_rules! generate_element_with_text {
 }
 
 macro_rules! generate_element_with_children {
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, attributes: [$($(#[$attr_meta:meta])* $attr:ident: $attr_type:ty = $attr_name:tt => $attr_action:tt),*,], children: [$($(#[$child_meta:meta])* $child_ident:ident: Vec<$child_type:ty> = ($child_name:tt, $child_ns:ident) => $child_constructor:ident),+]) => (
+        generate_element_with_children!($(#[$meta])* $elem, $name, $ns, attributes: [$($(#[$attr_meta])* $attr: $attr_type = $attr_name => $attr_action),*], children: [$($(#[$child_meta])* $child_ident: Vec<$child_type> = ($child_name, $child_ns) => $child_constructor),+]);
+    );
     ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, attributes: [$($(#[$attr_meta:meta])* $attr:ident: $attr_type:ty = $attr_name:tt => $attr_action:tt),*], children: [$($(#[$child_meta:meta])* $child_ident:ident: Vec<$child_type:ty> = ($child_name:tt, $child_ns:ident) => $child_constructor:ident),+]) => (
         $(#[$meta])*
         #[derive(Debug, Clone)]
@@ -448,4 +483,107 @@ macro_rules! generate_element_with_children {
             }
         }
     );
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, child: ($(#[$child_meta:meta])* $child_ident:ident: Option<$child_type:ty> = ($child_name:tt, $child_ns:ident) => $child_constructor:ident)) => (
+        generate_element_with_children!($(#[$meta])* $elem, $name, $ns, attributes: [], child: ($(#[$child_meta])* $child_ident: Option<$child_type> = ($child_name, $child_ns) => $child_constructor));
+    );
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, attributes: [$($(#[$attr_meta:meta])* $attr:ident: $attr_type:ty = $attr_name:tt => $attr_action:tt),*,], child: ($(#[$child_meta:meta])* $child_ident:ident: Option<$child_type:ty> = ($child_name:tt, $child_ns:ident) => $child_constructor:ident)) => (
+        generate_element_with_children!($(#[$meta])* $elem, $name, $ns, attributes: [$($(#[$attr_meta])* $attr: $attr_type = $attr_name => $attr_action),*], child: ($(#[$child_meta])* $child_ident: Option<$child_type> = ($child_name, $child_ns) => $child_constructor));
+    );
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, attributes: [$($(#[$attr_meta:meta])* $attr:ident: $attr_type:ty = $attr_name:tt => $attr_action:tt),*], child: ($(#[$child_meta:meta])* $child_ident:ident: Option<$child_type:ty> = ($child_name:tt, $child_ns:ident) => $child_constructor:ident)) => (
+        $(#[$meta])*
+        #[derive(Debug, Clone)]
+        pub struct $elem {
+            $(
+            $(#[$attr_meta])*
+            pub $attr: $attr_type,
+            )*
+            $(#[$child_meta])*
+            pub $child_ident: Option<$child_type>,
+        }
+
+        impl ::try_from::TryFrom<::minidom::Element> for $elem {
+            type Err = ::error::Error;
+
+            fn try_from(elem: ::minidom::Element) -> Result<$elem, ::error::Error> {
+                check_self!(elem, $name, $ns);
+                check_no_unknown_attributes!(elem, $name, [$($attr_name),*]);
+                let mut parsed_child = None;
+                for child in elem.children() {
+                    if child.is($child_name, ::ns::$child_ns) {
+                        parsed_child = Some($child_constructor::try_from(child.clone())?);
+                        continue;
+                    }
+                    return Err(::error::Error::ParseError(concat!("Unknown child in ", $name, " element.")));
+                }
+                Ok($elem {
+                    $(
+                    $attr: get_attr!(elem, $attr_name, $attr_action),
+                    )*
+                    $child_ident: parsed_child,
+                })
+            }
+        }
+
+        impl From<$elem> for ::minidom::Element {
+            fn from(elem: $elem) -> ::minidom::Element {
+                ::minidom::Element::builder($name)
+                        .ns(::ns::$ns)
+                        $(
+                        .attr($attr_name, elem.$attr)
+                        )*
+                        .append(elem.$child_ident)
+                        .build()
+            }
+        }
+    );
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, child: ($(#[$child_meta:meta])* $child_ident:ident: $child_type:ty = ($child_name:tt, $child_ns:ident) => $child_constructor:ident)) => (
+        generate_element_with_children!($(#[$meta])* $elem, $name, $ns, attributes: [], child: ($(#[$child_meta])* $child_ident: $child_type = ($child_name, $child_ns) => $child_constructor));
+    );
+    ($(#[$meta:meta])* $elem:ident, $name:tt, $ns:ident, attributes: [$($(#[$attr_meta:meta])* $attr:ident: $attr_type:ty = $attr_name:tt => $attr_action:tt),*], child: ($(#[$child_meta:meta])* $child_ident:ident: $child_type:ty = ($child_name:tt, $child_ns:ident) => $child_constructor:ident)) => (
+        $(#[$meta])*
+        #[derive(Debug, Clone)]
+        pub struct $elem {
+            $(
+            $(#[$attr_meta])*
+            pub $attr: $attr_type,
+            )*
+            $(#[$child_meta])*
+            pub $child_ident: $child_type,
+        }
+
+        impl ::try_from::TryFrom<::minidom::Element> for $elem {
+            type Err = ::error::Error;
+
+            fn try_from(elem: ::minidom::Element) -> Result<$elem, ::error::Error> {
+                check_self!(elem, $name, $ns);
+                check_no_unknown_attributes!(elem, $name, [$($attr_name),*]);
+                let mut parsed_child = None;
+                for child in elem.children() {
+                    if child.is($child_name, ::ns::$child_ns) {
+                        parsed_child = Some($child_constructor::try_from(child.clone())?);
+                        continue;
+                    }
+                    return Err(::error::Error::ParseError(concat!("Unknown child in ", $name, " element.")));
+                }
+                Ok($elem {
+                    $(
+                    $attr: get_attr!(elem, $attr_name, $attr_action),
+                    )*
+                    $child_ident: parsed_child.ok_or(::error::Error::ParseError(concat!("Missing child ", $child_name, " in ", $name, " element.")))?,
+                })
+            }
+        }
+
+        impl From<$elem> for ::minidom::Element {
+            fn from(elem: $elem) -> ::minidom::Element {
+                ::minidom::Element::builder($name)
+                        .ns(::ns::$ns)
+                        $(
+                        .attr($attr_name, elem.$attr)
+                        )*
+                        .append(elem.$child_ident)
+                        .build()
+            }
+        }
+    );
 }

src/pubsub/mod.rs

@@ -5,8 +5,10 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 pub mod event;
+pub mod pubsub;
 
 pub use self::event::PubSubEvent;
+pub use self::pubsub::PubSub;
 
 generate_id!(NodeName);
 generate_id!(ItemId);

src/pubsub/pubsub.rs

@@ -0,0 +1,490 @@
+// Copyright (c) 2018 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use try_from::TryFrom;
+
+use minidom::Element;
+use jid::Jid;
+
+use error::Error;
+
+use ns;
+
+use data_forms::DataForm;
+
+use pubsub::{NodeName, ItemId, Subscription, SubscriptionId};
+
+// TODO: a better solution would be to split this into a query and a result elements, like for
+// XEP-0030.
+generate_element_with_children!(
+    Affiliations, "affiliations", PUBSUB,
+    attributes: [
+        node: Option<NodeName> = "node" => optional,
+    ],
+    children: [
+        affiliations: Vec<Affiliation> = ("affiliation", PUBSUB) => Affiliation
+    ]
+);
+
+generate_attribute!(
+    AffiliationAttribute, "affiliation", {
+        Member => "member",
+        None => "none",
+        Outcast => "outcast",
+        Owner => "owner",
+        Publisher => "publisher",
+        PublishOnly => "publish-only",
+    }
+);
+
+generate_element_with_only_attributes!(
+    Affiliation, "affiliation", PUBSUB, [
+        node: NodeName = "node" => required,
+        affiliation: AffiliationAttribute = "affiliation" => required,
+    ]
+);
+
+generate_element_with_children!(
+    Configure, "configure", PUBSUB,
+    child: (
+        form: Option<DataForm> = ("x", DATA_FORMS) => DataForm
+    )
+);
+
+generate_element_with_only_attributes!(
+    Create, "create", PUBSUB, [
+        node: Option<NodeName> = "node" => optional,
+    ]
+);
+
+generate_element_with_only_attributes!(
+    Default, "default", PUBSUB, [
+        node: Option<NodeName> = "node" => optional,
+        // TODO: do we really want to support collection nodes?
+        // type: String = "type" => optional,
+    ]
+);
+
+generate_element_with_children!(
+    Items, "items", PUBSUB,
+    attributes: [
+        // TODO: should be an xs:positiveInteger, that is, an unbounded int ≥ 1.
+        max_items: Option<u32> = "max_items" => optional,
+        node: NodeName = "node" => required,
+        subid: Option<SubscriptionId> = "subid" => optional,
+    ],
+    children: [
+        items: Vec<Item> = ("item", PUBSUB) => Item
+    ]
+);
+
+#[derive(Debug, Clone)]
+pub struct Item {
+    payload: Option<Element>,
+    id: Option<ItemId>,
+}
+
+impl TryFrom<Element> for Item {
+    type Err = Error;
+
+    fn try_from(elem: Element) -> Result<Item, Error> {
+        check_self!(elem, "item", PUBSUB);
+        check_no_unknown_attributes!(elem, "item", ["id"]);
+        let mut payloads = elem.children().cloned().collect::<Vec<_>>();
+        let payload = payloads.pop();
+        if !payloads.is_empty() {
+            return Err(Error::ParseError("More than a single payload in item element."));
+        }
+        Ok(Item {
+            payload,
+            id: get_attr!(elem, "id", optional),
+        })
+    }
+}
+
+impl From<Item> for Element {
+    fn from(item: Item) -> Element {
+        Element::builder("item")
+                .ns(ns::PUBSUB)
+                .attr("id", item.id)
+                .append(item.payload)
+                .build()
+    }
+}
+
+generate_element_with_children!(
+    Options, "options", PUBSUB,
+    attributes: [
+        jid: Jid = "jid" => required,
+        node: Option<NodeName> = "node" => optional,
+        subid: Option<SubscriptionId> = "subid" => optional,
+    ],
+    child: (
+        form: Option<DataForm> = ("x", DATA_FORMS) => DataForm
+    )
+);
+
+generate_element_with_children!(
+    Publish, "publish", PUBSUB,
+    attributes: [
+        node: NodeName = "node" => required,
+    ],
+    children: [
+        items: Vec<Item> = ("item", PUBSUB) => Item
+    ]
+);
+
+generate_element_with_children!(
+    PublishOptions, "publish-options", PUBSUB,
+    child: (
+        form: DataForm = ("x", DATA_FORMS) => DataForm
+    )
+);
+
+generate_attribute!(Notify, "notify", bool);
+
+generate_element_with_children!(
+    Retract, "retract", PUBSUB,
+    attributes: [
+        node: NodeName = "node" => required,
+        notify: Notify = "notify" => default,
+    ],
+    children: [
+        items: Vec<Item> = ("item", PUBSUB) => Item
+    ]
+);
+
+#[derive(Debug, Clone)]
+pub struct SubscribeOptions {
+    required: bool,
+}
+
+impl TryFrom<Element> for SubscribeOptions {
+    type Err = Error;
+
+    fn try_from(elem: Element) -> Result<Self, Error> {
+        check_self!(elem, "subscribe-options", PUBSUB);
+        check_no_attributes!(elem, "subscribe-options");
+        let mut required = false;
+        for child in elem.children() {
+            if child.is("required", ns::PUBSUB) {
+                if required {
+                    return Err(Error::ParseError("More than one required element in subscribe-options."));
+                }
+                required = true;
+            } else {
+                return Err(Error::ParseError("Unknown child in subscribe-options element."));
+            }
+        }
+        Ok(SubscribeOptions { required })
+    }
+}
+
+impl From<SubscribeOptions> for Element {
+    fn from(subscribe_options: SubscribeOptions) -> Element {
+        Element::builder("subscribe-options")
+            .ns(ns::PUBSUB)
+            .append(if subscribe_options.required {
+                 vec!(Element::builder("required")
+                     .ns(ns::PUBSUB)
+                     .build())
+             } else {
+                 vec!()
+             })
+            .build()
+    }
+}
+
+generate_element_with_only_attributes!(
+    Subscribe, "subscribe", PUBSUB, [
+        jid: Jid = "jid" => required,
+        node: Option<NodeName> = "node" => optional,
+    ]
+);
+
+generate_element_with_children!(
+    Subscriptions, "subscriptions", PUBSUB,
+    attributes: [
+        node: Option<NodeName> = "node" => optional,
+    ],
+    children: [
+        subscription: Vec<SubscriptionElem> = ("subscription", PUBSUB) => SubscriptionElem
+    ]
+);
+
+generate_element_with_children!(
+    SubscriptionElem, "subscription", PUBSUB,
+    attributes: [
+        jid: Jid = "jid" => required,
+        node: Option<NodeName> = "node" => optional,
+        subid: Option<SubscriptionId> = "subid" => optional,
+        subscription: Option<Subscription> = "subscription" => optional,
+    ],
+    child: (
+        subscribe_options: Option<SubscribeOptions> = ("subscribe-options", PUBSUB) => SubscribeOptions
+    )
+);
+
+generate_element_with_only_attributes!(
+    Unsubscribe, "unsubscribe", PUBSUB, [
+        jid: Jid = "jid" => required,
+        node: Option<NodeName> = "node" => optional,
+        subid: Option<SubscriptionId> = "subid" => optional,
+    ]
+);
+
+#[derive(Debug, Clone)]
+pub enum PubSub {
+    Create {
+        create: Create,
+        configure: Option<Configure>
+    },
+    Publish {
+        publish: Publish,
+        publish_options: Option<PublishOptions>
+    },
+    Affiliations(Affiliations),
+    Default(Default),
+    Items(Items),
+    Retract(Retract),
+    Subscription(SubscriptionElem),
+    Subscriptions(Subscriptions),
+    Unsubscribe(Unsubscribe),
+}
+
+impl TryFrom<Element> for PubSub {
+    type Err = Error;
+
+    fn try_from(elem: Element) -> Result<PubSub, Error> {
+        check_self!(elem, "pubsub", PUBSUB);
+        check_no_attributes!(elem, "pubsub");
+
+        let mut payload = None;
+        for child in elem.children() {
+            if child.is("create", ns::PUBSUB) {
+                if payload.is_some() {
+                    return Err(Error::ParseError("…"));
+                }
+                let create = Create::try_from(child.clone())?;
+                payload = Some(PubSub::Create { create, configure: None });
+            } else {
+                return Err(Error::ParseError("Unknown child in pubsub element."));
+            }
+        }
+        Ok(payload.ok_or(Error::ParseError("No payload in pubsub element."))?)
+    }
+}
+
+impl From<PubSub> for Element {
+    fn from(pubsub: PubSub) -> Element {
+        Element::builder("pubsub")
+            .ns(ns::PUBSUB)
+            .append(match pubsub {
+                 PubSub::Create { create, configure } => {
+                     let mut elems = vec!(Element::from(create));
+                     if let Some(configure) = configure {
+                         elems.push(Element::from(configure));
+                     }
+                     elems
+                 },
+                 PubSub::Publish { publish, publish_options } => {
+                     let mut elems = vec!(Element::from(publish));
+                     if let Some(publish_options) = publish_options {
+                         elems.push(Element::from(publish_options));
+                     }
+                     elems
+                 },
+                 PubSub::Affiliations(affiliations) => vec!(Element::from(affiliations)),
+                 PubSub::Default(default) => vec!(Element::from(default)),
+                 PubSub::Items(items) => vec!(Element::from(items)),
+                 PubSub::Retract(retract) => vec!(Element::from(retract)),
+                 PubSub::Subscription(subscription) => vec!(Element::from(subscription)),
+                 PubSub::Subscriptions(subscriptions) => vec!(Element::from(subscriptions)),
+                 PubSub::Unsubscribe(unsubscribe) => vec!(Element::from(unsubscribe)),
+             })
+            .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use compare_elements::NamespaceAwareCompare;
+
+    #[test]
+    fn invalid_empty_pubsub() {
+        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'/>".parse().unwrap();
+        let error = PubSub::try_from(elem).unwrap_err();
+        let message = match error {
+            Error::ParseError(string) => string,
+            _ => panic!(),
+        };
+        assert_eq!(message, "No payload in pubsub element.");
+        /*
+        match pubsub {
+            PubSub::EmptyItems { node } => assert_eq!(node, NodeName(String::from("coucou"))),
+            _ => panic!(),
+        }
+        */
+    }
+
+    #[test]
+    fn publish_option() {
+        let elem: Element = "<publish-options xmlns='http://jabber.org/protocol/pubsub'><x xmlns='jabber:x:data' type='submit'><field var='FORM_TYPE' type='hidden'><value>http://jabber.org/protocol/pubsub#publish-options</value></field></x></publish-options>".parse().unwrap();
+        let publish_options = PublishOptions::try_from(elem).unwrap();
+        assert_eq!(&publish_options.form.form_type.unwrap(), "http://jabber.org/protocol/pubsub#publish-options");
+    }
+
+    #[test]
+    fn subscribe_options() {
+        let elem1: Element = "<subscribe-options xmlns='http://jabber.org/protocol/pubsub'/>".parse().unwrap();
+        let subscribe_options1 = SubscribeOptions::try_from(elem1).unwrap();
+        assert_eq!(subscribe_options1.required, false);
+
+        let elem2: Element = "<subscribe-options xmlns='http://jabber.org/protocol/pubsub'><required/></subscribe-options>".parse().unwrap();
+        let subscribe_options2 = SubscribeOptions::try_from(elem2).unwrap();
+        assert_eq!(subscribe_options2.required, true);
+    }
+
+    /*
+    #[test]
+    fn test_simple_items() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='coucou'><item id='test' node='huh?' publisher='test@coucou'/></items></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::PublishedItems { node, items } => {
+                assert_eq!(node, NodeName(String::from("coucou")));
+                assert_eq!(items[0].id, Some(ItemId(String::from("test"))));
+                assert_eq!(items[0].node, Some(NodeName(String::from("huh?"))));
+                assert_eq!(items[0].publisher, Some(Jid::from_str("test@coucou").unwrap()));
+                assert_eq!(items[0].payload, None);
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_simple_pep() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='something'><item><foreign xmlns='example:namespace'/></item></items></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::PublishedItems { node, items } => {
+                assert_eq!(node, NodeName(String::from("something")));
+                assert_eq!(items[0].id, None);
+                assert_eq!(items[0].node, None);
+                assert_eq!(items[0].publisher, None);
+                match items[0].payload {
+                    Some(ref elem) => assert!(elem.is("foreign", "example:namespace")),
+                    _ => panic!(),
+                }
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_simple_retract() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='something'><retract id='coucou'/><retract id='test'/></items></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::RetractedItems { node, items } => {
+                assert_eq!(node, NodeName(String::from("something")));
+                assert_eq!(items[0], ItemId(String::from("coucou")));
+                assert_eq!(items[1], ItemId(String::from("test")));
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_simple_delete() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><delete node='coucou'><redirect uri='hello'/></delete></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::Delete { node, redirect } => {
+                assert_eq!(node, NodeName(String::from("coucou")));
+                assert_eq!(redirect, Some(String::from("hello")));
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_simple_purge() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><purge node='coucou'/></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::Purge { node } => {
+                assert_eq!(node, NodeName(String::from("coucou")));
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_simple_configure() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><configuration node='coucou'><x xmlns='jabber:x:data' type='result'><field var='FORM_TYPE' type='hidden'><value>http://jabber.org/protocol/pubsub#node_config</value></field></x></configuration></event>".parse().unwrap();
+        let event = PubSub::try_from(elem).unwrap();
+        match event {
+            PubSub::Configuration { node, form: _ } => {
+                assert_eq!(node, NodeName(String::from("coucou")));
+                //assert_eq!(form.type_, Result_);
+            },
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn test_invalid() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><coucou node='test'/></event>".parse().unwrap();
+        let error = PubSub::try_from(elem).unwrap_err();
+        let message = match error {
+            Error::ParseError(string) => string,
+            _ => panic!(),
+        };
+        assert_eq!(message, "Unknown child in event element.");
+    }
+
+    #[test]
+    fn test_invalid_attribute() {
+        let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event' coucou=''/>".parse().unwrap();
+        let error = PubSub::try_from(elem).unwrap_err();
+        let message = match error {
+            Error::ParseError(string) => string,
+            _ => panic!(),
+        };
+        assert_eq!(message, "Unknown attribute in event element.");
+    }
+
+    #[test]
+    fn test_ex221_subscription() {
+        let elem: Element = r#"
+<event xmlns='http://jabber.org/protocol/pubsub#event'>
+  <subscription
+      expiry='2006-02-28T23:59:59+00:00'
+      jid='francisco@denmark.lit'
+      node='princely_musings'
+      subid='ba49252aaa4f5d320c24d3766f0bdcade78c78d3'
+      subscription='subscribed'/>
+</event>
+"#.parse().unwrap();
+        let event = PubSub::try_from(elem.clone()).unwrap();
+        match event.clone() {
+            PubSub::Subscription { node, expiry, jid, subid, subscription } => {
+                assert_eq!(node, NodeName(String::from("princely_musings")));
+                assert_eq!(subid, Some(SubscriptionId(String::from("ba49252aaa4f5d320c24d3766f0bdcade78c78d3"))));
+                assert_eq!(subscription, Some(Subscription::Subscribed));
+                assert_eq!(jid, Some(Jid::from_str("francisco@denmark.lit").unwrap()));
+                assert_eq!(expiry, Some("2006-02-28T23:59:59Z".parse().unwrap()));
+            },
+            _ => panic!(),
+        }
+
+        let elem2: Element = event.into();
+        assert!(elem.compare_to(&elem2));
+    }
+    */
+}