shingara-blather 0.4.8

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

@@ -0,0 +1,226 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def disco_info_xml
+  <<-XML
+  <iq type='result'
+      from='romeo@montague.net/orchard'
+      to='juliet@capulet.com/balcony'
+      id='info4'>
+    <query xmlns='http://jabber.org/protocol/disco#info'>
+      <identity
+          category='client'
+          type='pc'
+          name='Gabber'/>
+      <feature var='jabber:iq:time'/>
+      <feature var='jabber:iq:version'/>
+    </query>
+  </iq>
+  XML
+end
+
+describe Blather::Stanza::Iq::DiscoInfo do
+  it 'registers itself' do
+    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
+    n = Blather::Stanza::Iq::DiscoInfo.new nil, 'music', [], []
+    n.node.must_equal 'music'
+    n.node = :foo
+    n.node.must_equal 'foo'
+  end
+
+  it 'inherits a list of identities' do
+    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 [Blather::Stanza::Iq::DiscoInfo::Identity]
+  end
+
+  it 'inherits a list of features' do
+    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 [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
+
+describe 'Blather::Stanza::Iq::DiscoInfo identities' do
+  it 'takes a list of hashes for identities' do
+    ids = [
+      {:name => 'name', :type => 'type', :category => 'category'},
+      {:name => 'name1', :type => 'type1', :category => 'category1'},
+    ]
+
+    control = [ Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
+                Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
+
+    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 = [ Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category]),
+                Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
+
+    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 = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type 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 = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
+
+    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
+
+  it 'takes a mix of hashes and identity objects as identities' do
+    ids = [
+      {:name => 'name', :type => 'type', :category => 'category'},
+      Blather::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 = 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
+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| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
+
+    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| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
+
+    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 = [Blather::Stanza::Iq::DiscoInfo::Feature.new('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 = [Blather::Stanza::Iq::DiscoInfo::Feature.new('feature1')]
+
+    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| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
+    features[1] = control[1]
+
+    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
+  it 'will auto-inherit nodes' do
+    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
+  end
+
+  it 'has a category attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.category.must_equal :cat
+    n.category = :foo
+    n.category.must_equal :foo
+  end
+
+  it 'has a type attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.type.must_equal :type
+    n.type = :foo
+    n.type.must_equal :foo
+  end
+
+  it 'has a name attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.name.must_equal 'name'
+    n.name = :foo
+    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_equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    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
+  it 'will auto-inherit nodes' do
+    n = parse_stanza "<feature var='ipv6' />"
+    i = Blather::Stanza::Iq::DiscoInfo::Feature.new n.root
+    i.var.must_equal 'ipv6'
+  end
+
+  it 'has a var attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Feature.new 'var'
+    n.var.must_equal 'var'
+    n.var = :foo
+    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_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
+    a.wont_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
+  end
+end

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

@@ -0,0 +1,148 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def disco_items_xml
+  <<-XML
+  <iq type='result'
+      from='catalog.shakespeare.lit'
+      to='romeo@montague.net/orchard'
+      id='items2'>
+    <query xmlns='http://jabber.org/protocol/disco#items'>
+      <item jid='catalog.shakespeare.lit'
+            node='books'
+            name='Books by and about Shakespeare'/>
+      <item jid='catalog.shakespeare.lit'
+            node='clothing'
+            name='Wear your literary taste with pride'/>
+      <item jid='catalog.shakespeare.lit'
+            node='music'
+            name='Music from the time of Shakespeare'/>
+    </query>
+  </iq>
+  XML
+end
+
+describe Blather::Stanza::Iq::DiscoItems do
+  it 'registers itself' do
+    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
+    n = Blather::Stanza::Iq::DiscoItems.new nil, 'music', []
+    n.node.must_equal 'music'
+    n.node = :foo
+    n.node.must_equal 'foo'
+  end
+
+  it 'inherits a list of identities' do
+    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 [Blather::Stanza::Iq::DiscoItems::Item]
+  end
+
+  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 = [ 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 = 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 = [ 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 = 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 = [Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node 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 = [Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+
+    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
+
+  it 'takes a mix of hashes and identity objects as items' do
+    items = [
+      {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'},
+      Blather::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 = 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
+  it 'will auto-inherit nodes' do
+    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 = 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 Blather::JID.new('baz@foo/bar')
+  end
+
+  it 'has a node attribute' do
+    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 = 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 = 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

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+describe Blather::Stanza::Iq::Query do
+  it 'registers itself' do
+    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 = Blather::Stanza::Iq::Query.new
+    query.xpath('query').wont_be_empty
+  end
+
+  it 'ensures a query node exists when calling #query' do
+    query = Blather::Stanza::Iq::Query.new
+    query.remove_child :query
+    query.xpath('query').must_be_empty
+
+    query.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 = Blather::Stanza::Iq::Query.new type
+      query.type.must_equal type
+    end
+  end
+
+  it 'sets type to "result" on reply' do
+    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 = Blather::Stanza::Iq::Query.new
+    query.type.must_equal :get
+    query.reply!
+    query.type.must_equal :result
+  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

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def roster_xml
+<<-XML
+<iq to='juliet@example.com/balcony' type='result' id='roster_1'>
+  <query xmlns='jabber:iq:roster'>
+    <item jid='romeo@example.net'
+          name='Romeo'
+          subscription='both'>
+      <group>Friends</group>
+    </item>
+    <item jid='mercutio@example.org'
+          name='Mercutio'
+          subscription='from'>
+      <group>Friends</group>
+    </item>
+    <item jid='benvolio@example.org'
+          name='Benvolio'
+          subscription='both'>
+      <group>Friends</group>
+    </item>
+  </query>
+</iq>
+XML
+end
+
+describe Blather::Stanza::Iq::Roster do
+  it 'registers itself' do
+    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 = 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 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 = Blather::Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
+    i.name.must_equal 'foobar'
+  end
+
+  it 'can be initialized with a subscription' do
+    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 = 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 = Blather::XMPPNode.new 'item'
+    n[:jid] = 'n@d/r'
+    n[:subscription] = 'both'
+
+    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 = 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 = 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]
+    i.groups.sort.must_equal %w[a b c]
+  end
+
+  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 = 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 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 = 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 Blather::JID.new('n@d/r')
+  end
+
+  it 'has a name attribute' do
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
+    i.name = 'name'
+    i.name.must_equal 'name'
+  end
+
+  it 'has a subscription attribute' do
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
+    i.subscription = :both
+    i.subscription.must_equal :both
+  end
+
+  it 'has an ask attribute' do
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
+    i.ask = :subscribe
+    i.ask.must_equal :subscribe
+  end
+end

data/spec/blather/stanza/iq_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe Blather::Stanza::Iq do
+  it 'registers itself' do
+    Blather::XMPPNode.class_from_registration(:iq, nil).must_equal Blather::Stanza::Iq
+  end
+
+  it 'must be importable' do
+    doc = parse_stanza "<iq from='juliet@example.com/balcony' type='set' id='roster_4'></iq>"
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq
+  end
+
+  it 'creates a new Iq stanza defaulted as a get' do
+    Blather::Stanza::Iq.new.type.must_equal :get
+  end
+
+  it 'sets the id when created' do
+    Blather::Stanza::Iq.new.id.wont_be_nil
+  end
+
+  it 'creates a new Stanza::Iq object on import' do
+    Blather::Stanza::Iq.import(Blather::XMPPNode.new('iq')).must_be_kind_of Blather::Stanza::Iq
+  end
+
+  it 'creates a proper object based on its children' do
+    n = Blather::XMPPNode.new('iq')
+    n << Blather::XMPPNode.new('query', n.document)
+    Blather::Stanza::Iq.import(n).must_be_kind_of Blather::Stanza::Iq::Query
+  end
+
+  it 'ensures type is one of Stanza::Iq::VALID_TYPES' do
+    lambda { Blather::Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
+      n = Blather::Stanza::Iq.new valid_type
+      n.type.must_equal valid_type
+    end
+  end
+
+  Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
+    it "provides a helper (#{valid_type}?) for type #{valid_type}" do
+      Blather::Stanza::Iq.new.must_respond_to :"#{valid_type}?"
+    end
+  end
+end