sprsquish-blather 0.3.4 → 0.4.0

data/spec/blather/stanza/discos/disco_info_spec.rb

@@ -18,9 +18,14 @@ def disco_info_xml
   XML
 end
 
-describe 'Blather::Stanza::Iq::DiscoInfo' do
+describe Blather::Stanza::Iq::DiscoInfo do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#info').must_equal Blather::Stanza::Iq::DiscoInfo
+    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#info').must_equal Blather::Stanza::Iq::DiscoInfo
+  end
+
+  it 'must be importable' do
+    doc = parse_stanza disco_info_xml
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::DiscoInfo
   end
 
   it 'has a node attribute' do
@@ -31,17 +36,23 @@ describe 'Blather::Stanza::Iq::DiscoInfo' do
   end
 
   it 'inherits a list of identities' do
-    n = XML::Document.string disco_info_xml
-    r = Stanza::Iq::DiscoInfo.new.inherit n.root
+    n = parse_stanza disco_info_xml
+    r = Blather::Stanza::Iq::DiscoInfo.new.inherit n.root
     r.identities.size.must_equal 1
-    r.identities.map { |i| i.class }.uniq.must_equal [Stanza::Iq::DiscoInfo::Identity]
+    r.identities.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::DiscoInfo::Identity]
   end
 
   it 'inherits a list of features' do
-    n = XML::Document.string disco_info_xml
-    r = Stanza::Iq::DiscoInfo.new.inherit n.root
+    n = parse_stanza disco_info_xml
+    r = Blather::Stanza::Iq::DiscoInfo.new.inherit n.root
     r.features.size.must_equal 2
-    r.features.map { |i| i.class }.uniq.must_equal [Stanza::Iq::DiscoInfo::Feature]
+    r.features.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::DiscoInfo::Feature]
+  end
+
+  it 'is constructed properly' do
+    n = Blather::Stanza::Iq::DiscoInfo.new :get, '/path/to/node'
+    n.to = 'to@jid.com'
+    n.find("/iq[@to='to@jid.com' and @type='get' and @id='#{n.id}']/ns:query[@node='/path/to/node']", :ns => Blather::Stanza::Iq::DiscoInfo.registered_ns).wont_be_empty
   end
 end
 
@@ -52,35 +63,35 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
       {:name => 'name1', :type => 'type1', :category => 'category1'},
     ]
 
-    control = [ Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
-                Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
+    control = [ Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
+                Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, ids
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, ids
     di.identities.size.must_equal 2
     di.identities.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a list of Identity objects as identities' do
-    control = [ Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
-                Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
+    control = [ Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
+                Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, control
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, control
     di.identities.size.must_equal 2
     di.identities.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a single hash as identity' do
-    control = [Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
+    control = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, {:name => 'name', :type => 'type', :category => 'category'}
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, {:name => 'name', :type => 'type', :category => 'category'}
     di.identities.size.must_equal 1
     di.identities.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a single identity object as identity' do
-    control = [Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
+    control = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, control.first
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, control.first
     di.identities.size.must_equal 1
     di.identities.each { |i| control.include?(i).must_equal true }
   end
@@ -88,13 +99,13 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
   it 'takes a mix of hashes and identity objects as identities' do
     ids = [
       {:name => 'name', :type => 'type', :category => 'category'},
-      Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1]),
+      Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1]),
     ]
 
-    control = [ Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
-                Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
+    control = [ Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
+                Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, ids
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, ids
     di.identities.size.must_equal 2
     di.identities.each { |i| control.include?(i).must_equal true }
   end
@@ -103,53 +114,53 @@ end
 describe 'Blather::Stanza::Iq::DiscoInfo features' do
   it 'takes a list of features as strings' do
     features = %w[feature1 feature2 feature3]
-    control = features.map { |f| Stanza::Iq::DiscoInfo::Feature.new f }
+    control = features.map { |f| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, [], features
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], features
     di.features.size.must_equal 3
     di.features.each { |f| control.include?(f).must_equal true }
   end
 
   it 'takes a list of features as Feature objects' do
     features = %w[feature1 feature2 feature3]
-    control = features.map { |f| Stanza::Iq::DiscoInfo::Feature.new f }
+    control = features.map { |f| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, [], control
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], control
     di.features.size.must_equal 3
     di.features.each { |f| control.include?(f).must_equal true }
   end
 
   it 'takes a single string' do
-    control = [Stanza::Iq::DiscoInfo::Feature.new('feature1')]
+    control = [Blather::Stanza::Iq::DiscoInfo::Feature.new('feature1')]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, [], 'feature1'
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], 'feature1'
     di.features.size.must_equal 1
     di.features.each { |f| control.include?(f).must_equal true }
   end
 
   it 'takes a single Feature object' do
-    control = [Stanza::Iq::DiscoInfo::Feature.new('feature1')]
+    control = [Blather::Stanza::Iq::DiscoInfo::Feature.new('feature1')]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, [], control.first
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], control.first
     di.features.size.must_equal 1
     di.features.each { |f| control.include?(f).must_equal true }
   end
 
   it 'takes a mixed list of features as Feature objects and strings' do
     features = %w[feature1 feature2 feature3]
-    control = features.map { |f| Stanza::Iq::DiscoInfo::Feature.new f }
+    control = features.map { |f| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
     features[1] = control[1]
 
-    di = Stanza::Iq::DiscoInfo.new nil, nil, [], features
+    di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], features
     di.features.size.must_equal 3
     di.features.each { |f| control.include?(f).must_equal true }
   end
 end
 
-describe 'Blather::Stanza::Iq::DiscoInfo::Identity' do
+describe Blather::Stanza::Iq::DiscoInfo::Identity do
   it 'will auto-inherit nodes' do
-    n = XML::Document.string "<identity name='Personal Events' type='pep' category='pubsub' node='publish' />"
-    i = Stanza::Iq::DiscoInfo::Identity.new n.root
+    n = parse_stanza "<identity name='Personal Events' type='pep' category='pubsub' node='publish' />"
+    i = Blather::Stanza::Iq::DiscoInfo::Identity.new n.root
     i.name.must_equal 'Personal Events'
     i.type.must_equal :pep
     i.category.must_equal :pubsub
@@ -176,18 +187,22 @@ describe 'Blather::Stanza::Iq::DiscoInfo::Identity' do
     n.name.must_equal 'foo'
   end
 
+  it 'raises an error if equality is sent a non DiscoInfo::Identity object' do
+    a = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    lambda { a == 'foo' }.must_raise RuntimeError
+  end
+
   it 'can determine equality' do
     a = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    a.must_respond_to :eql?
     a.must_equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    a.wont_equal "<identity name='Personal Events' type='pep' category='pubsub' node='publish' />"
+    a.wont_equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[not-name not-type not-cat])
   end
 end
 
-describe 'Blather::Stanza::Iq::DiscoInfo::Feature' do
+describe Blather::Stanza::Iq::DiscoInfo::Feature do
   it 'will auto-inherit nodes' do
-    n = XML::Document.string "<feature var='ipv6' />"
-    i = Stanza::Iq::DiscoInfo::Feature.new n.root
+    n = parse_stanza "<feature var='ipv6' />"
+    i = Blather::Stanza::Iq::DiscoInfo::Feature.new n.root
     i.var.must_equal 'ipv6'
   end
 
@@ -198,10 +213,14 @@ describe 'Blather::Stanza::Iq::DiscoInfo::Feature' do
     n.var.must_equal 'foo'
   end
 
+  it 'raises an error if equality is sent a non DiscoInfo::Feature object' do
+    a = Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
+    lambda { a == 'foo' }.must_raise RuntimeError
+  end
+
   it 'can determine equality' do
     a = Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
-    a.must_respond_to :eql?
     a.must_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
-    a.wont_equal "<feature var='ipv6' />"
+    a.wont_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
   end
 end

data/spec/blather/stanza/discos/disco_items_spec.rb

@@ -21,9 +21,19 @@ def disco_items_xml
   XML
 end
 
-describe 'Blather::Stanza::Iq::DiscoItems' do
+describe Blather::Stanza::Iq::DiscoItems do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#items').must_equal Blather::Stanza::Iq::DiscoItems
+    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#items').must_equal Blather::Stanza::Iq::DiscoItems
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.import(parse_stanza(disco_items_xml).root).must_be_instance_of Blather::Stanza::Iq::DiscoItems
+  end
+
+  it 'is constructed properly' do
+    n = Blather::Stanza::Iq::DiscoItems.new :get, '/path/to/node'
+    n.to = 'to@jid.com'
+    n.find("/iq[@to='to@jid.com' and @type='get' and @id='#{n.id}']/ns:query[@node='/path/to/node']", :ns => Blather::Stanza::Iq::DiscoItems.registered_ns).wont_be_empty
   end
 
   it 'has a node attribute' do
@@ -34,49 +44,47 @@ describe 'Blather::Stanza::Iq::DiscoItems' do
   end
 
   it 'inherits a list of identities' do
-    n = XML::Document.string disco_items_xml
-    r = Stanza::Iq::DiscoItems.new.inherit n.root
+    n = parse_stanza disco_items_xml
+    r = Blather::Stanza::Iq::DiscoItems.new.inherit n.root
     r.items.size.must_equal 3
-    r.items.map { |i| i.class }.uniq.must_equal [Stanza::Iq::DiscoItems::Item]
+    r.items.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::DiscoItems::Item]
   end
-end
 
-describe 'Blather::Stanza::Iq::DiscoItems items' do
   it 'takes a list of hashes for items' do
     items = [
       {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'},
       {:jid => 'baz@foo/bar', :node => 'node1', :name => 'name1'},
     ]
 
-    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
-                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+    control = [ Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Blather::Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
 
-    di = Stanza::Iq::DiscoItems.new nil, nil, items
+    di = Blather::Stanza::Iq::DiscoItems.new nil, nil, items
     di.items.size.must_equal 2
     di.items.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a list of Item objects as items' do
-    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
-                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+    control = [ Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Blather::Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
 
-    di = Stanza::Iq::DiscoItems.new nil, nil, control
+    di = Blather::Stanza::Iq::DiscoItems.new nil, nil, control
     di.items.size.must_equal 2
     di.items.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a single hash as identity' do
-    control = [Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+    control = [Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
 
-    di = Stanza::Iq::DiscoItems.new nil, nil, {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'}
+    di = Blather::Stanza::Iq::DiscoItems.new nil, nil, {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'}
     di.items.size.must_equal 1
     di.items.each { |i| control.include?(i).must_equal true }
   end
 
   it 'takes a single identity object as identity' do
-    control = [Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+    control = [Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
 
-    di = Stanza::Iq::DiscoItems.new nil, nil, control.first
+    di = Blather::Stanza::Iq::DiscoItems.new nil, nil, control.first
     di.items.size.must_equal 1
     di.items.each { |i| control.include?(i).must_equal true }
   end
@@ -84,53 +92,57 @@ describe 'Blather::Stanza::Iq::DiscoItems items' do
   it 'takes a mix of hashes and identity objects as items' do
     items = [
       {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'},
-      Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1]),
+      Blather::Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1]),
     ]
 
-    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
-                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+    control = [ Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Blather::Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
 
-    di = Stanza::Iq::DiscoItems.new nil, nil, items
+    di = Blather::Stanza::Iq::DiscoItems.new nil, nil, items
     di.items.size.must_equal 2
     di.items.each { |i| control.include?(i).must_equal true }
   end
 end
 
-describe 'Blather::Stanza::Iq::DiscoItems::Item' do
+describe Blather::Stanza::Iq::DiscoItems::Item do
   it 'will auto-inherit nodes' do
-    n = XML::Document.string "<item jid='foo@bar/baz' node='music' name='Music from the time of Shakespeare' />"
-    i = Stanza::Iq::DiscoItems::Item.new n.root
-    i.jid.must_equal JID.new('foo@bar/baz')
+    n = parse_stanza "<item jid='foo@bar/baz' node='music' name='Music from the time of Shakespeare' />"
+    i = Blather::Stanza::Iq::DiscoItems::Item.new n.root
+    i.jid.must_equal Blather::JID.new('foo@bar/baz')
     i.node.must_equal 'music'
     i.name.must_equal 'Music from the time of Shakespeare'
   end
 
   it 'has a jid attribute' do
-    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz'
-    n.jid.must_be_kind_of JID
-    n.jid.must_equal JID.new('foo@bar/baz')
+    n = Blather::Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz'
+    n.jid.must_be_kind_of Blather::JID
+    n.jid.must_equal Blather::JID.new('foo@bar/baz')
     n.jid = 'baz@foo/bar'
-    n.jid.must_equal JID.new('baz@foo/bar')
+    n.jid.must_equal Blather::JID.new('baz@foo/bar')
   end
 
   it 'has a node attribute' do
-    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', 'music'
+    n = Blather::Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', 'music'
     n.node.must_equal 'music'
     n.node = 'book'
     n.node.must_equal 'book'
   end
 
   it 'has a name attribute' do
-    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', nil, 'Music from the time of Shakespeare'
+    n = Blather::Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', nil, 'Music from the time of Shakespeare'
     n.name.must_equal 'Music from the time of Shakespeare'
     n.name = 'Books by and about Shakespeare'
     n.name.must_equal 'Books by and about Shakespeare'
   end
 
+  it 'raises an error when compared against a non DiscoItems::Item' do
+    a = Blather::Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    lambda { a == 'test' }.must_raise RuntimeError
+  end
+
   it 'can determine equality' do
-    a = Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
-    a.must_respond_to :eql?
-    a.must_equal Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
-    a.wont_equal "<item jid='foo@bar/baz' node='music' name='Music from the time of Shakespeare' />"
+    a = Blather::Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.must_equal Blather::Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.wont_equal Blather::Stanza::Iq::DiscoItems::Item.new('not-foo@bar/baz')
   end
 end

data/spec/blather/stanza/iq/query_spec.rb

@@ -1,41 +1,64 @@
 require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
 
-describe 'Blather::Stanza::Iq::Query' do
+describe Blather::Stanza::Iq::Query do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, nil).must_equal Stanza::Iq::Query
+    Blather::XMPPNode.class_from_registration(:query, nil).must_equal Blather::Stanza::Iq::Query
+  end
+
+  it 'can be imported' do
+    doc = parse_stanza <<-XML
+      <iq from='juliet@example.com/balcony' type='set' id='roster_4'>
+        <query>
+          <item jid='nurse@example.com' subscription='remove'/>
+        </query>
+      </iq>
+    XML
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::Query
   end
 
   it 'ensures a query node is present on create' do
-    query = Stanza::Iq::Query.new
-    query.children.detect { |n| n.element_name == 'query' }.wont_be_nil
+    query = Blather::Stanza::Iq::Query.new
+    query.xpath('query').wont_be_empty
   end
 
   it 'ensures a query node exists when calling #query' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.remove_child :query
-    query.children.detect { |n| n.element_name == 'query' }.must_be_nil
+    query.xpath('query').must_be_empty
 
     query.query.wont_be_nil
-    query.children.detect { |n| n.element_name == 'query' }.wont_be_nil
+    query.xpath('query').wont_be_empty
   end
 
   [:get, :set, :result, :error].each do |type|
     it "can be set as \"#{type}\"" do
-      query = Stanza::Iq::Query.new type
+      query = Blather::Stanza::Iq::Query.new type
       query.type.must_equal type
     end
   end
 
   it 'sets type to "result" on reply' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.type.must_equal :get
     reply = query.reply.type.must_equal :result
   end
 
   it 'sets type to "result" on reply!' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.type.must_equal :get
     query.reply!
     query.type.must_equal :result
   end
-end
+
+  it 'can be registered under a namespace' do
+    class QueryNs < Blather::Stanza::Iq::Query; register :query_ns, nil, 'query:ns'; end
+    Blather::XMPPNode.class_from_registration(:query, 'query:ns').must_equal QueryNs
+    query_ns = QueryNs.new
+    query_ns.xpath('query').must_be_empty
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.must_equal 1
+
+    query_ns.query
+    query_ns.query
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.must_equal 1
+  end
+end

data/spec/blather/stanza/iq/roster_spec.rb

@@ -24,59 +24,76 @@ def roster_xml
 XML
 end
 
-describe 'Blather::Stanza::Iq::Roster' do
+describe Blather::Stanza::Iq::Roster do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, 'jabber:iq:roster').must_equal Stanza::Iq::Roster
+    Blather::XMPPNode.class_from_registration(:query, 'jabber:iq:roster').must_equal Blather::Stanza::Iq::Roster
   end
 
   it 'ensures newly inherited items are RosterItem objects' do
-    n = XML::Document.string roster_xml
-    r = Stanza::Iq::Roster.new.inherit n.root
-    r.items.map { |i| i.class }.uniq.must_equal [Stanza::Iq::Roster::RosterItem]
+    n = parse_stanza roster_xml
+    r = Blather::Stanza::Iq::Roster.new.inherit n.root
+    r.items.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::Roster::RosterItem]
+  end
+
+  it 'can be created with #import' do
+    doc = parse_stanza roster_xml
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::Roster
   end
 end
 
-describe 'Blather::Stanza::Iq::Roster::RosterItem' do
-  it 'can be initialized with just a JID' do
-    i = Stanza::Iq::Roster::RosterItem.new 'n@d/r'
-    i.jid.must_equal JID.new('n@d/r')
+describe Blather::Stanza::Iq::Roster::RosterItem do
+  it 'can be initialized with just a Blather::JID' do
+    i = Blather::Stanza::Iq::Roster::RosterItem.new 'n@d/r'
+    i.jid.must_equal Blather::JID.new('n@d/r')
   end
 
   it 'can be initialized with a name' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
     i.name.must_equal 'foobar'
   end
 
   it 'can be initialized with a subscription' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, nil, :both
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, nil, :both
     i.subscription.must_equal :both
   end
 
   it 'can be initialized with ask (subscription sub-type)' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, nil, nil, :subscribe
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, nil, nil, :subscribe
     i.ask.must_equal :subscribe
   end
 
+  it 'can be initailized with a hash' do
+    control = { :jid          => 'j@d/r',
+                :name         => 'name',
+                :subscription => :both,
+                :ask          => :subscribe }
+    i = Blather::Stanza::Iq::Roster::RosterItem.new control
+    i.jid.must_equal Blather::JID.new(control[:jid])
+    i.name.must_equal control[:name]
+    i.subscription.must_equal control[:subscription]
+    i.ask.must_equal control[:ask]
+  end
+
   it 'inherits a node when initialized with one' do
-    n = XMPPNode.new 'item'
-    n['jid'] = 'n@d/r'
-    n['subscription'] = 'both'
+    n = Blather::XMPPNode.new 'item'
+    n[:jid] = 'n@d/r'
+    n[:subscription] = 'both'
 
-    i = Stanza::Iq::Roster::RosterItem.new n
-    i.jid.must_equal JID.new('n@d/r')
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n
+    i.jid.must_equal Blather::JID.new('n@d/r')
     i.subscription.must_equal :both
   end
 
   it 'has a #groups helper that gives an array of groups' do
-    n = XML::Document.string "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :groups
     i.groups.sort.must_equal %w[bar baz foo]
   end
 
   it 'has a helper to set the groups' do
-    n = XML::Document.string "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :groups=
     i.groups.sort.must_equal %w[bar baz foo]
     i.groups = %w[a b c]
@@ -85,38 +102,38 @@ describe 'Blather::Stanza::Iq::Roster::RosterItem' do
 
   it 'can be easily converted into a proper stanza' do
     xml = "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    n = XML::Document.string xml
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza xml
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :to_stanza
     s = i.to_stanza
-    s.must_be_kind_of Stanza::Iq::Roster
-    s.items.first.jid.must_equal JID.new('romeo@example.net')
+    s.must_be_kind_of Blather::Stanza::Iq::Roster
+    s.items.first.jid.must_equal Blather::JID.new('romeo@example.net')
     s.items.first.groups.sort.must_equal %w[bar baz foo]
   end
 
   it 'has an "attr_accessor" for jid' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.must_respond_to :jid
     i.jid.must_be_nil
     i.must_respond_to :jid=
     i.jid = 'n@d/r'
-    i.jid.must_equal JID.new('n@d/r')
+    i.jid.must_equal Blather::JID.new('n@d/r')
   end
 
   it 'has a name attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.name = 'name'
     i.name.must_equal 'name'
   end
 
   it 'has a subscription attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.subscription = :both
     i.subscription.must_equal :both
   end
 
   it 'has an ask attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.ask = :subscribe
     i.ask.must_equal :subscribe
   end