blather 0.3.4 → 0.4.0

data/spec/blather/roster_item_spec.rb

@@ -1,54 +1,65 @@
 require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
 
-describe 'Blather::RosterItem' do
-  it 'initializes with JID' do
-    jid = JID.new(jid)
-    i = RosterItem.new jid
+describe Blather::RosterItem do
+  it 'can be initialized with Blather::JID' do
+    jid = Blather::JID.new(jid)
+    i = Blather::RosterItem.new jid
     i.jid.must_equal jid
   end
 
-  it 'initializes with an Iq::RosterItem' do
+  it 'can be initialized with an Iq::RosterItem' do
     jid = 'n@d/r'
-    i = RosterItem.new Stanza::Iq::Roster::RosterItem.new(jid)
-    i.jid.must_equal JID.new(jid).stripped
+    i = Blather::RosterItem.new Blather::Stanza::Iq::Roster::RosterItem.new(jid)
+    i.jid.must_equal Blather::JID.new(jid).stripped
   end
 
-  it 'has a JID setter that strips the JID' do
-    jid = JID.new('n@d/r')
-    i = RosterItem.new nil
+  it 'can be initialized with a string' do
+    jid = 'n@d/r'
+    i = Blather::RosterItem.new jid
+    i.jid.must_equal Blather::JID.new(jid).stripped
+  end
+
+  it 'returns the same object when intialized with a Blather::RosterItem' do
+    control = Blather::RosterItem.new 'n@d/r'
+    Blather::RosterItem.new(control).must_be_same_as control
+  end
+
+  it 'has a Blather::JID setter that strips the Blather::JID' do
+    jid = Blather::JID.new('n@d/r')
+    i = Blather::RosterItem.new nil
     i.jid = jid
     i.jid.must_equal jid.stripped
   end
 
   it 'has a subscription setter that forces a symbol' do
-    i = RosterItem.new nil
+    i = Blather::RosterItem.new nil
     i.subscription = 'remove'
     i.subscription.must_equal :remove
   end
 
   it 'forces the type of subscription' do
-    proc { RosterItem.new(nil).subscription = 'foo' }.must_raise Blather::ArgumentError
+    proc { Blather::RosterItem.new(nil).subscription = 'foo' }.must_raise Blather::ArgumentError
   end
 
   it 'returns :none if the subscription field is blank' do
-    RosterItem.new(nil).subscription.must_equal :none
+    Blather::RosterItem.new(nil).subscription.must_equal :none
   end
 
   it 'ensure #ask is a symbol' do
-    i = RosterItem.new(nil)
+    i = Blather::RosterItem.new(nil)
     i.ask = 'subscribe'
     i.ask.must_equal :subscribe
   end
 
   it 'forces #ask to be :subscribe or nothing at all' do
-    proc { RosterItem.new(nil).ask = 'foo' }.must_raise Blather::ArgumentError
+    proc { Blather::RosterItem.new(nil).ask = 'foo' }.must_raise Blather::ArgumentError
   end
 
   it 'generates a stanza with #to_stanza' do
-    jid = JID.new('n@d/r')
-    i = RosterItem.new jid
+    jid = Blather::JID.new('n@d/r')
+    i = Blather::RosterItem.new jid
     s = i.to_stanza
-    s.must_be_kind_of Stanza::Iq::Roster
+    s.must_be_kind_of Blather::Stanza::Iq::Roster
     s.items.first.jid.must_equal jid.stripped
   end
 
@@ -63,14 +74,14 @@ describe 'Blather::RosterItem' do
   end
 
   def setup_item_with_presences
-    @jid = JID.new('n@d/r')
-    @i = RosterItem.new @jid
+    @jid = Blather::JID.new('n@d/r')
+    @i = Blather::RosterItem.new @jid
 
-    @p = Stanza::Presence::Status.new(:away)
+    @p = Blather::Stanza::Presence::Status.new(:away)
     @p.from = 'n@d/a'
     @p.priority = 0
 
-    @p2 = Stanza::Presence::Status.new(:dnd)
+    @p2 = Blather::Stanza::Presence::Status.new(:dnd)
     @p2.from = 'n@d/b'
     @p2.priority = -1
 
@@ -79,7 +90,7 @@ describe 'Blather::RosterItem' do
   end
 
   it 'initializes groups to [nil] if the item is not part of a group' do
-    i = RosterItem.new 'n@d'
+    i = Blather::RosterItem.new 'n@d'
     i.groups.must_equal [nil]
   end
 end

data/spec/blather/roster_spec.rb

@@ -1,15 +1,15 @@
 require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
 
-describe 'Blather::Roster' do
+describe Blather::Roster do
   before do
     @stream = mock()
     @stream.stubs(:send_data)
 
     @stanza = mock()
-    items = []; 4.times { |n| items << JID.new("n@d/#{n}r") }
+    items = []; 4.times { |n| items << Blather::JID.new("n@d/#{n}r") }
     @stanza.stubs(:items).returns(items)
 
-    @roster = Roster.new(@stream, @stanza)
+    @roster = Blather::Roster.new(@stream, @stanza)
   end
 
   it 'initializes with items' do
@@ -23,7 +23,7 @@ describe 'Blather::Roster' do
   end
 
   it 'processes @stanzas with add requests' do
-    s = Stanza::Iq::Roster::RosterItem.new('a@b/c').to_stanza
+    s = Blather::Stanza::Iq::Roster::RosterItem.new('a@b/c').to_stanza
     proc { @roster.process(s) }.must_change('@roster.items.length', :by => 1)
   end
 
@@ -35,16 +35,16 @@ describe 'Blather::Roster' do
 
   it 'allows an item to be pushed' do
     jid = 'a@b/c'
-    item = RosterItem.new(JID.new(jid))
+    item = Blather::RosterItem.new(Blather::JID.new(jid))
     proc { @roster.push(item) }.must_change('@roster.items.length', :by => 1)
     @roster[jid].wont_be_nil
   end
 
   it 'aliases #<< to #push and returns self to allow for chaining' do
     jid = 'a@b/c'
-    item = RosterItem.new(JID.new(jid))
+    item = Blather::RosterItem.new(Blather::JID.new(jid))
     jid2 = 'd@e/f'
-    item2 = RosterItem.new(JID.new(jid2))
+    item2 = Blather::RosterItem.new(Blather::JID.new(jid2))
     proc { @roster << item << item2 }.must_change('@roster.items.length', :by => 2)
     @roster[jid].wont_be_nil
     @roster[jid2].wont_be_nil
@@ -53,24 +53,24 @@ describe 'Blather::Roster' do
   it 'sends a @roster addition over the wire' do
     stream = mock()
     stream.expects(:send_data)
-    roster = Roster.new stream, @stanza
+    roster = Blather::Roster.new stream, @stanza
     roster.push('a@b/c')
   end
 
-  it 'removes a JID' do
+  it 'removes a Blather::JID' do
     proc { @roster.delete 'n@d' }.must_change('@roster.items.length', :by => -1)
   end
 
   it 'sends a @roster removal over the wire' do
     stream = mock(:send_data => nil)
-    roster = Roster.new stream, @stanza
+    roster = Blather::Roster.new stream, @stanza
     roster.delete('a@b/c')
   end
 
   it 'returns an item through []' do
     item = @roster['n@d']
-    item.must_be_kind_of RosterItem
-    item.jid.must_equal JID.new('n@d')
+    item.must_be_kind_of Blather::RosterItem
+    item.jid.must_equal Blather::JID.new('n@d')
   end
 
   it 'responds to #each' do
@@ -86,4 +86,19 @@ describe 'Blather::Roster' do
     items.delete 'n@d'
     items.wont_equal @roster.items
   end
+
+  it 'will group roster items' do
+    @roster.delete 'n@d'
+    item1 = Blather::RosterItem.new("n1@d")
+    item1.groups = ['group1', 'group2']
+    item2 = Blather::RosterItem.new("n2@d")
+    item2.groups = ['group1', 'group3']
+    @roster << item1 << item2
+
+    @roster.grouped.must_equal({
+      'group1' => [item1, item2],
+      'group2' => [item1],
+      'group3' => [item2]
+    })
+  end
 end

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