tp-blather 0.8.2

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

@@ -0,0 +1,247 @@
+require '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'
+          xml:lang='en'/>
+      <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').should == Blather::Stanza::Iq::DiscoInfo
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.parse(disco_info_xml).should be_instance_of Blather::Stanza::Iq::DiscoInfo
+  end
+
+  it 'has a node attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo.new nil, 'music', [], []
+    n.node.should == 'music'
+    n.node = :foo
+    n.node.should == '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.should == 1
+    r.identities.map { |i| i.class }.uniq.should == [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.should == 2
+    r.features.map { |i| i.class }.uniq.should == [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).should_not be_empty
+  end
+
+  it 'allows adding of identities' do
+    di = Blather::Stanza::Iq::DiscoInfo.new
+    di.identities.size.should == 0
+    di.identities = [{:name => 'name', :type => 'type', :category => 'category'}]
+    di.identities.size.should == 1
+    di.identities += [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
+    di.identities.size.should == 2
+    di.identities = nil
+    di.identities.size.should == 0
+  end
+
+  it 'allows adding of features' do
+    di = Blather::Stanza::Iq::DiscoInfo.new
+    di.features.size.should == 0
+    di.features = ["feature1"]
+    di.features.size.should == 1
+    di.features += [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
+    di.features.size.should == 2
+    di.features = nil
+    di.features.size.should == 0
+  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.should == 2
+    di.identities.each { |i| control.include?(i).should == 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.should == 2
+    di.identities.each { |i| control.include?(i).should == 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.should == 1
+    di.identities.each { |i| control.include?(i).should == 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.should == 1
+    di.identities.each { |i| control.include?(i).should == 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.should == 2
+    di.identities.each { |i| control.include?(i).should == 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.should == 3
+    di.features.each { |f| control.include?(f).should == 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.should == 3
+    di.features.each { |f| control.include?(f).should == 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.should == 1
+    di.features.each { |f| control.include?(f).should == 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.should == 1
+    di.features.each { |f| control.include?(f).should == 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.should == 3
+    di.features.each { |f| control.include?(f).should == 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' xml:lang='en' />"
+    i = Blather::Stanza::Iq::DiscoInfo::Identity.new n.root
+    i.name.should == 'Personal Events'
+    i.type.should == :pep
+    i.category.should == :pubsub
+    i.xml_lang.should == 'en'
+  end
+
+  it 'has a category attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.category.should == :cat
+    n.category = :foo
+    n.category.should == :foo
+  end
+
+  it 'has a type attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.type.should == :type
+    n.type = :foo
+    n.type.should == :foo
+  end
+
+  it 'has a name attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    n.name.should == 'name'
+    n.name = :foo
+    n.name.should == 'foo'
+  end
+
+  it 'has an xml:lang attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat en])
+    n.xml_lang.should == 'en'
+    n.xml_lang = 'de'
+    n.xml_lang.should == 'de'
+  end
+
+  it 'can determine equality' do
+    a = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    a.should == Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    a.should_not 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.should == 'ipv6'
+  end
+
+  it 'has a var attribute' do
+    n = Blather::Stanza::Iq::DiscoInfo::Feature.new 'var'
+    n.var.should == 'var'
+    n.var = :foo
+    n.var.should == 'foo'
+  end
+
+  it 'can determine equality' do
+    a = Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
+    a.should == Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
+    a.should_not equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
+  end
+end

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

@@ -0,0 +1,154 @@
+require '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').should == Blather::Stanza::Iq::DiscoItems
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.parse(disco_items_xml).should 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).should_not be_empty
+  end
+
+  it 'has a node attribute' do
+    n = Blather::Stanza::Iq::DiscoItems.new nil, 'music', []
+    n.node.should == 'music'
+    n.node = :foo
+    n.node.should == '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.should == 3
+    r.items.map { |i| i.class }.uniq.should == [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.should == 2
+    di.items.each { |i| control.include?(i).should == 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.should == 2
+    di.items.each { |i| control.include?(i).should == 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.should == 1
+    di.items.each { |i| control.include?(i).should == 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.should == 1
+    di.items.each { |i| control.include?(i).should == 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.should == 2
+    di.items.each { |i| control.include?(i).should == true }
+  end
+
+  it 'allows adding of items' do
+    di = Blather::Stanza::Iq::DiscoItems.new
+    di.items.size.should == 0
+    di.items = [{:jid => 'foo@bar/baz', :node => 'node', :name => 'name'}]
+    di.items.size.should == 1
+    di.items += [Blather::Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+    di.items.size.should == 2
+    di.items = nil
+    di.items.size.should == 0
+  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.should == Blather::JID.new('foo@bar/baz')
+    i.node.should == 'music'
+    i.name.should == '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.should be_kind_of Blather::JID
+    n.jid.should == Blather::JID.new('foo@bar/baz')
+    n.jid = 'baz@foo/bar'
+    n.jid.should == 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.should == 'music'
+    n.node = 'book'
+    n.node.should == '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.should == 'Music from the time of Shakespeare'
+    n.name = 'Books by and about Shakespeare'
+    n.name.should == 'Books by and about Shakespeare'
+  end
+
+  it 'can determine equality' do
+    a = Blather::Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.should == Blather::Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.should_not equal Blather::Stanza::Iq::DiscoItems::Item.new('not-foo@bar/baz')
+  end
+end

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

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+def command_xml
+  <<-XML
+  <iq type='result'
+      from='catalog.shakespeare.lit'
+      to='romeo@montague.net/orchard'
+      id='form2'>
+    <command xmlns='http://jabber.org/protocol/commands'
+             node='node1'
+             sessionid='dqjiodmqlmakm'>
+      <x xmlns='jabber:x:data' type='form'>
+        <field var='field-name' type='text-single' label='description' />
+      </x>
+    </command>
+  </iq>
+  XML
+end
+
+describe Blather::Stanza::Iq::Command do
+  it 'registers itself' do
+    Blather::XMPPNode.class_from_registration(:command, 'http://jabber.org/protocol/commands').should == Blather::Stanza::Iq::Command
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.parse(command_xml).should be_instance_of Blather::Stanza::Iq::Command
+  end
+
+  it 'ensures a command node is present on create' do
+    c = Blather::Stanza::Iq::Command.new
+    c.xpath('xmlns:command', :xmlns => Blather::Stanza::Iq::Command.registered_ns).should_not be_empty
+  end
+
+  it 'ensures a command node exists when calling #command' do
+    c = Blather::Stanza::Iq::Command.new
+    c.remove_children :command
+    c.xpath('ns:command', :ns => Blather::Stanza::Iq::Command.registered_ns).should be_empty
+
+    c.command.should_not be_nil
+    c.xpath('ns:command', :ns => Blather::Stanza::Iq::Command.registered_ns).should_not be_empty
+  end
+
+  Blather::Stanza::Iq::Command::VALID_ACTIONS.each do |valid_action|
+    it "provides a helper (#{valid_action}?) for action #{valid_action}" do
+      Blather::Stanza::Iq::Command.new.should respond_to :"#{valid_action}?"
+    end
+  end
+
+  Blather::Stanza::Iq::Command::VALID_STATUS.each do |valid_status|
+    it "provides a helper (#{valid_status}?) for status #{valid_status}" do
+      Blather::Stanza::Iq::Command.new.should respond_to :"#{valid_status}?"
+    end
+  end
+
+  Blather::Stanza::Iq::Command::VALID_NOTE_TYPES.each do |valid_note_type|
+    it "provides a helper (#{valid_note_type}?) for note_type #{valid_note_type}" do
+      Blather::Stanza::Iq::Command.new.should respond_to :"#{valid_note_type}?"
+    end
+  end
+
+  [:cancel, :execute, :complete, :next, :prev].each do |action|
+    it "action can be set as \"#{action}\"" do
+      c = Blather::Stanza::Iq::Command.new nil, nil, action
+      c.action.should == action
+    end
+  end
+
+  [:get, :set, :result, :error].each do |type|
+    it "can be set as \"#{type}\"" do
+      c = Blather::Stanza::Iq::Command.new type
+      c.type.should == type
+    end
+  end
+
+  it 'sets type to "result" on reply' do
+    c = Blather::Stanza::Iq::Command.new
+    c.type.should == :set
+    reply = c.reply.type.should == :result
+  end
+
+  it 'sets type to "result" on reply!' do
+    c = Blather::Stanza::Iq::Command.new
+    c.type.should == :set
+    c.reply!
+    c.type.should == :result
+  end
+
+  it 'removes action on reply' do
+    c = Blather::XMPPNode.parse command_xml
+    c.action.should == :execute
+    c.reply.action.should == nil
+  end
+
+  it 'removes action on reply!' do
+    c = Blather::XMPPNode.parse command_xml
+    c.action.should == :execute
+    c.reply!
+    c.action.should == nil
+  end
+
+  it 'can be registered under a namespace' do
+    class CommandNs < Blather::Stanza::Iq::Command; register :command_ns, nil, 'command:ns'; end
+    Blather::XMPPNode.class_from_registration(:command, 'command:ns').should == CommandNs
+    c_ns = CommandNs.new
+    c_ns.xpath('command').should be_empty
+    c_ns.xpath('ns:command', :ns => 'command:ns').size.should == 1
+
+    c_ns.command
+    c_ns.command
+    c_ns.xpath('ns:command', :ns => 'command:ns').size.should == 1
+  end
+
+  it 'is constructed properly' do
+    n = Blather::Stanza::Iq::Command.new :set, "node", :execute
+    n.to = 'to@jid.com'
+    n.find("/iq[@to='to@jid.com' and @type='set' and @id='#{n.id}']/ns:command[@node='node' and @action='execute']", :ns => Blather::Stanza::Iq::Command.registered_ns).should_not be_empty
+  end
+
+  it 'has an action attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.action.should == :execute
+    n.action = :cancel
+    n.action.should == :cancel
+  end
+
+  it 'must default action to :execute on import' do
+    n = Blather::XMPPNode.parse(command_xml)
+    n.action.should == :execute
+  end
+
+  it 'has a status attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.status.should == :executing
+    n.status = :completed
+    n.status.should == :completed
+  end
+
+  it 'has a sessionid attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.sessionid.should == nil
+    n.sessionid = "somerandomstring"
+    n.sessionid.should == Digest::SHA1.hexdigest("somerandomstring")
+  end
+
+  it 'has a sessionid? attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.sessionid?.should == false
+    n.new_sessionid!
+    n.sessionid?.should == true
+  end
+
+  it 'has an allowed_actions attribute' do
+    n = Blather::XMPPNode.parse command_xml
+    n.allowed_actions.should == [:execute]
+    n.allowed_actions = [:next, :prev]
+    (n.allowed_actions - [:next, :prev, :execute]).should be_empty
+    n.remove_allowed_actions!
+    n.allowed_actions.should == [:execute]
+    n.allowed_actions += [:next]
+    (n.allowed_actions - [:next, :execute]).should be_empty
+
+    r = Blather::Stanza::Iq::Command.new
+    r.allowed_actions.should == [:execute]
+    r.allowed_actions += [:prev]
+    (r.allowed_actions - [:prev, :execute]).should be_empty
+  end
+
+  it 'has a primary_allowed_action attribute' do
+    n = Blather::XMPPNode.parse command_xml
+    n.primary_allowed_action.should == :execute
+    n.primary_allowed_action = :next
+    n.primary_allowed_action.should == :next
+  end
+
+  it 'has a note_type attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.note_type.should == nil
+    n.note_type = :info
+    n.note_type.should == :info
+  end
+
+  it 'has a note_text attribute' do
+    n = Blather::Stanza::Iq::Command.new
+    n.note_text.should == nil
+    n.note_text = "Some text"
+    n.note_text.should == "Some text"
+  end
+
+  it 'makes a form child available' do
+    n = Blather::XMPPNode.parse(command_xml)
+    n.form.fields.size.should == 1
+    n.form.fields.map { |f| f.class }.uniq.should == [Blather::Stanza::X::Field]
+    n.form.should be_instance_of Blather::Stanza::X
+
+    r = Blather::Stanza::Iq::Command.new
+    r.form.type = :form
+    r.form.type.should == :form
+  end
+
+  it 'ensures the form child is a child of command' do
+    r = Blather::Stanza::Iq::Command.new
+    r.form
+    r.command.xpath('ns:x', :ns => Blather::Stanza::X.registered_ns).should_not be_empty
+    r.xpath('ns:x', :ns => Blather::Stanza::X.registered_ns).should be_empty
+  end
+end