blather 0.6.2 → 0.7.0

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

@@ -10,32 +10,36 @@ end
 
 describe Blather::Stanza::Iq::Ping do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:ping, 'urn:xmpp:ping').must_equal Blather::Stanza::Iq::Ping
+    Blather::XMPPNode.class_from_registration(:ping, 'urn:xmpp:ping').should == Blather::Stanza::Iq::Ping
   end
 
   it 'can be imported' do
-    doc = parse_stanza ping_xml
-    node = Blather::XMPPNode.import(doc.root)
-    node.must_be_instance_of Blather::Stanza::Iq::Ping
+    node = Blather::XMPPNode.parse ping_xml
+    node.should be_instance_of Blather::Stanza::Iq::Ping
   end
 
   it 'ensures a ping node is present on create' do
     iq = Blather::Stanza::Iq::Ping.new
-    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').wont_be_empty
+    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').should_not be_empty
   end
 
   it 'ensures a ping node exists when calling #ping' do
     iq = Blather::Stanza::Iq::Ping.new
     iq.ping.remove
-    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').must_be_empty
+    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').should be_empty
 
-    iq.ping.wont_be_nil
-    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').wont_be_empty
+    iq.ping.should_not be_nil
+    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').should_not be_empty
   end
 
   it 'responds with an empty IQ' do
     ping = Blather::Stanza::Iq::Ping.new :get, 'one@example.com', 'abc123'
     ping.from = 'two@example.com'
-    ping.reply.must_equal Blather::Stanza::Iq.new(:result, 'two@example.com', 'abc123')
+    expected_pong = Blather::Stanza::Iq::Ping.new(:result, 'two@example.com', 'abc123').tap do |pong|
+      pong.from = 'one@example.com'
+    end
+    reply = ping.reply
+    reply.should == expected_pong
+    reply.children.count.should == 0
   end
 end

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

@@ -2,63 +2,63 @@ require '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
+    Blather::XMPPNode.class_from_registration(:query, nil).should == Blather::Stanza::Iq::Query
   end
 
   it 'can be imported' do
-    doc = parse_stanza <<-XML
+    string = <<-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
+    Blather::XMPPNode.parse(string).should 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
+    query.xpath('query').should_not 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.xpath('query').should be_empty
 
-    query.query.wont_be_nil
-    query.xpath('query').wont_be_empty
+    query.query.should_not be_nil
+    query.xpath('query').should_not 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
+      query.type.should == 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
+    query.type.should == :get
+    reply = query.reply.type.should == :result
   end
 
   it 'sets type to "result" on reply!' do
     query = Blather::Stanza::Iq::Query.new
-    query.type.must_equal :get
+    query.type.should == :get
     query.reply!
-    query.type.must_equal :result
+    query.type.should == :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
+    Blather::XMPPNode.class_from_registration(:query, 'query:ns').should == 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.xpath('query').should be_empty
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.should == 1
 
     query_ns.query
     query_ns.query
-    query_ns.xpath('ns:query', :ns => 'query:ns').size.must_equal 1
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.should == 1
   end
 end

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

@@ -26,40 +26,39 @@ 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
+    Blather::XMPPNode.class_from_registration(:query, 'jabber:iq:roster').should == 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]
+    r.items.map { |i| i.class }.uniq.should == [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
+    Blather::XMPPNode.parse(roster_xml).should 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')
+    i.jid.should == Blather::JID.new('n@d/r').stripped
   end
 
   it 'can be initialized with a name' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
-    i.name.must_equal 'foobar'
+    i.name.should == '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
+    i.subscription.should == :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
+    i.ask.should == :subscribe
   end
 
   it 'can be initailized with a hash' do
@@ -68,10 +67,10 @@ describe Blather::Stanza::Iq::Roster::RosterItem do
                 :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]
+    i.jid.should == Blather::JID.new(control[:jid]).stripped
+    i.name.should == control[:name]
+    i.subscription.should == control[:subscription]
+    i.ask.should == control[:ask]
   end
 
   it 'inherits a node when initialized with one' do
@@ -80,61 +79,61 @@ describe Blather::Stanza::Iq::Roster::RosterItem do
     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
+    i.jid.should == Blather::JID.new('n@d/r')
+    i.subscription.should == :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]
+    i.should respond_to :groups
+    i.groups.sort.should == %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.should respond_to :groups=
+    i.groups.sort.should == %w[bar baz foo]
     i.groups = %w[a b c]
-    i.groups.sort.must_equal %w[a b c]
+    i.groups.sort.should == %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
+    i.should 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]
+    s.should be_kind_of Blather::Stanza::Iq::Roster
+    s.items.first.jid.should == Blather::JID.new('romeo@example.net')
+    s.items.first.groups.sort.should == %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.should respond_to :jid
+    i.jid.should be_nil
+    i.should respond_to :jid=
     i.jid = 'n@d/r'
-    i.jid.must_equal Blather::JID.new('n@d/r')
+    i.jid.should == Blather::JID.new('n@d/r').stripped
   end
 
   it 'has a name attribute' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.name = 'name'
-    i.name.must_equal 'name'
+    i.name.should == 'name'
   end
 
   it 'has a subscription attribute' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.subscription = :both
-    i.subscription.must_equal :both
+    i.subscription.should == :both
   end
 
   it 'has an ask attribute' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.ask = :subscribe
-    i.ask.must_equal :subscribe
+    i.ask.should == :subscribe
   end
 end

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

@@ -23,38 +23,35 @@ end
 
 describe Blather::Stanza::Iq::S5b do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/bytestreams').must_equal Blather::Stanza::Iq::S5b
+    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/bytestreams').should == Blather::Stanza::Iq::S5b
   end
 
   it 'can be imported' do
-    doc = parse_stanza s5b_open_xml
-    node = Blather::XMPPNode.import(doc.root)
-    node.must_be_instance_of Blather::Stanza::Iq::S5b
+    node = Blather::XMPPNode.parse s5b_open_xml
+    node.should be_instance_of Blather::Stanza::Iq::S5b
   end
 
   it 'can get sid' do
-    doc = parse_stanza s5b_open_xml
-    node = Blather::XMPPNode.import(doc.root)
-    node.sid.must_equal 'vxf9n471bn46'
+    node = Blather::XMPPNode.parse s5b_open_xml
+    node.sid.should == 'vxf9n471bn46'
   end
 
   it 'can get streamhosts' do
-    doc = parse_stanza s5b_open_xml
-    node = Blather::XMPPNode.import(doc.root)
-    node.streamhosts.size.must_equal 2
+    node = Blather::XMPPNode.parse s5b_open_xml
+    node.streamhosts.size.should == 2
   end
 
   it 'can set streamhosts' do
     node = Blather::Stanza::Iq::S5b.new
     node.streamhosts += [{:jid => 'test@example.com/foo', :host => '192.168.5.1', :port => 123}]
-    node.streamhosts.size.must_equal 1
+    node.streamhosts.size.should == 1
     node.streamhosts += [Blather::Stanza::Iq::S5b::StreamHost.new('test2@example.com/foo', '192.168.5.2', 123)]
-    node.streamhosts.size.must_equal 2
+    node.streamhosts.size.should == 2
   end
 
   it 'can get and set streamhost-used' do
     node = Blather::Stanza::Iq::S5b.new
     node.streamhost_used = 'used@example.com/foo'
-    node.streamhost_used.jid.to_s.must_equal 'used@example.com/foo'
+    node.streamhost_used.jid.to_s.should == 'used@example.com/foo'
   end
 end

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

@@ -27,41 +27,39 @@ end
 
 describe Blather::Stanza::Iq::Si do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:si, 'http://jabber.org/protocol/si').must_equal Blather::Stanza::Iq::Si
+    Blather::XMPPNode.class_from_registration(:si, 'http://jabber.org/protocol/si').should == Blather::Stanza::Iq::Si
   end
 
   it 'can be imported' do
-    doc = parse_stanza si_xml
-    node = Blather::XMPPNode.import(doc.root)
-    node.must_be_instance_of Blather::Stanza::Iq::Si
-    node.si.must_be_instance_of Blather::Stanza::Iq::Si::Si
+    node = Blather::XMPPNode.parse si_xml
+    node.should be_instance_of Blather::Stanza::Iq::Si
+    node.si.should be_instance_of Blather::Stanza::Iq::Si::Si
   end
 
   it 'ensures a si node is present on create' do
     iq = Blather::Stanza::Iq::Si.new
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').wont_be_empty
+    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').should_not be_empty
   end
 
   it 'ensures a si node exists when calling #si' do
     iq = Blather::Stanza::Iq::Si.new
     iq.si.remove
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').must_be_empty
+    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').should be_empty
 
-    iq.si.wont_be_nil
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').wont_be_empty
+    iq.si.should_not be_nil
+    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').should_not be_empty
   end
 
   it 'ensures a si node is replaced when calling #si=' do
-    doc = parse_stanza si_xml
-    iq = Blather::XMPPNode.import(doc.root)
+    iq = Blather::XMPPNode.parse si_xml
 
     new_si = Blather::Stanza::Iq::Si::Si.new
     new_si.id = 'a1'
 
     iq.si = new_si
 
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').size.must_equal 1
-    iq.si.id.must_equal 'a1'
+    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').size.should == 1
+    iq.si.id.should == 'a1'
   end
 end
 
@@ -71,31 +69,30 @@ describe Blather::Stanza::Iq::Si::Si do
     si.id = 'a1'
     si.mime_type = 'text/plain'
     si.profile = 'http://jabber.org/protocol/si/profile/file-transfer'
-    si.id.must_equal 'a1'
-    si.mime_type.must_equal 'text/plain'
-    si.profile.must_equal 'http://jabber.org/protocol/si/profile/file-transfer'
+    si.id.should == 'a1'
+    si.mime_type.should == 'text/plain'
+    si.profile.should == 'http://jabber.org/protocol/si/profile/file-transfer'
   end
 end
 
 describe Blather::Stanza::Iq::Si::Si::File do
   it 'can be initialized with name and size' do
     file = Blather::Stanza::Iq::Si::Si::File.new('test.txt', 123)
-    file.name.must_equal 'test.txt'
-    file.size.must_equal 123
+    file.name.should == 'test.txt'
+    file.size.should == 123
   end
 
   it 'can be initialized with node' do
-    doc = parse_stanza si_xml
-    node = Blather::XMPPNode.import(doc.root)
+    node = Blather::XMPPNode.parse si_xml
 
     file = Blather::Stanza::Iq::Si::Si::File.new node.find_first('.//ns:file', :ns => 'http://jabber.org/protocol/si/profile/file-transfer')
-    file.name.must_equal 'test.txt'
-    file.size.must_equal 1022
+    file.name.should == 'test.txt'
+    file.size.should == 1022
   end
 
   it 'can set and get description' do
     file = Blather::Stanza::Iq::Si::Si::File.new('test.txt', 123)
     file.desc = 'This is a test. If this were a real file...'
-    file.desc.must_equal 'This is a test. If this were a real file...'
+    file.desc.should == 'This is a test. If this were a real file...'
   end
 end

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

@@ -12,41 +12,39 @@ end
 
 describe Blather::Stanza::Iq::Vcard do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:vCard, 'vcard-temp').must_equal Blather::Stanza::Iq::Vcard
+    Blather::XMPPNode.class_from_registration(:vCard, 'vcard-temp').should == Blather::Stanza::Iq::Vcard
   end
 
   it 'can be imported' do
-    doc = parse_stanza vcard_xml
-    query = Blather::XMPPNode.import(doc.root)
-    query.must_be_instance_of Blather::Stanza::Iq::Vcard
-    query.vcard.must_be_instance_of Blather::Stanza::Iq::Vcard::Vcard
+    query = Blather::XMPPNode.parse vcard_xml
+    query.should be_instance_of Blather::Stanza::Iq::Vcard
+    query.vcard.should be_instance_of Blather::Stanza::Iq::Vcard::Vcard
   end
 
   it 'ensures a vcard node is present on create' do
     query = Blather::Stanza::Iq::Vcard.new
-    query.xpath('ns:vCard', :ns => 'vcard-temp').wont_be_empty
+    query.xpath('ns:vCard', :ns => 'vcard-temp').should_not be_empty
   end
 
   it 'ensures a vcard node exists when calling #vcard' do
     query = Blather::Stanza::Iq::Vcard.new
     query.vcard.remove
-    query.xpath('ns:vCard', :ns => 'vcard-temp').must_be_empty
+    query.xpath('ns:vCard', :ns => 'vcard-temp').should be_empty
 
-    query.vcard.wont_be_nil
-    query.xpath('ns:vCard', :ns => 'vcard-temp').wont_be_empty
+    query.vcard.should_not be_nil
+    query.xpath('ns:vCard', :ns => 'vcard-temp').should_not be_empty
   end
 
   it 'ensures a vcard node is replaced when calling #vcard=' do
-    doc = parse_stanza vcard_xml
-    query = Blather::XMPPNode.import(doc.root)
+    query = Blather::XMPPNode.parse vcard_xml
 
     new_vcard = Blather::Stanza::Iq::Vcard::Vcard.new
     new_vcard["NICKNAME"] = 'Mercutio'
 
     query.vcard = new_vcard
 
-    query.xpath('ns:vCard', :ns => 'vcard-temp').size.must_equal 1
-    query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content.must_equal 'Mercutio'
+    query.xpath('ns:vCard', :ns => 'vcard-temp').size.should == 1
+    query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content.should == 'Mercutio'
   end
 end
 
@@ -54,43 +52,42 @@ describe Blather::Stanza::Iq::Vcard::Vcard do
   it 'can set vcard elements' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['NICKNAME'] = 'Romeo'
-    query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content.must_equal 'Romeo'
+    query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content.should == 'Romeo'
   end
 
   it 'can set deep vcard elements' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['PHOTO/TYPE'] = 'image/png'
     query.vcard['PHOTO/BINVAL'] = '===='
-    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.size.must_equal 2
-    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'TYPE' && n.content == 'image/png' }.wont_be_nil
-    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'BINVAL' && n.content == '====' }.wont_be_nil
+    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.size.should == 2
+    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'TYPE' && n.content == 'image/png' }.should_not be_nil
+    query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'BINVAL' && n.content == '====' }.should_not be_nil
   end
 
   it 'can get vcard elements' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['NICKNAME'] = 'Romeo'
-    query.vcard['NICKNAME'].must_equal 'Romeo'
+    query.vcard['NICKNAME'].should == 'Romeo'
   end
 
   it 'can get deep vcard elements' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['PHOTO/TYPE'] = 'image/png'
     query.vcard['PHOTO/BINVAL'] = '===='
-    query.vcard['PHOTO/TYPE'].must_equal 'image/png'
-    query.vcard['PHOTO/BINVAL'].must_equal '===='
+    query.vcard['PHOTO/TYPE'].should == 'image/png'
+    query.vcard['PHOTO/BINVAL'].should == '===='
   end
 
   it 'returns nil on vcard elements which does not exist' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['NICKNAME'] = 'Romeo'
-    query.vcard['FN'].must_be_nil
+    query.vcard['FN'].should be_nil
   end
 
   it 'can update vcard elements' do
-    doc = parse_stanza vcard_xml
-    query = Blather::XMPPNode.import(doc.root)
-    query.vcard['NICKNAME'].must_equal 'Romeo'
+    query = Blather::XMPPNode.parse vcard_xml
+    query.vcard['NICKNAME'].should == 'Romeo'
     query.vcard['NICKNAME'] = 'Mercutio'
-    query.vcard['NICKNAME'].must_equal 'Mercutio'
+    query.vcard['NICKNAME'].should == 'Mercutio'
   end
 end