blather 1.2.0 → 2.0.0

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

@@ -10,26 +10,26 @@ end
 
 describe Blather::Stanza::Iq::Ping do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:ping, 'urn:xmpp:ping').should == Blather::Stanza::Iq::Ping
+    expect(Blather::XMPPNode.class_from_registration(:ping, 'urn:xmpp:ping')).to eq(Blather::Stanza::Iq::Ping)
   end
 
   it 'can be imported' do
     node = Blather::XMPPNode.parse ping_xml
-    node.should be_instance_of Blather::Stanza::Iq::Ping
+    expect(node).to 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').should_not be_empty
+    expect(iq.xpath('ns:ping', :ns => 'urn:xmpp:ping')).not_to 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').should be_empty
+    expect(iq.xpath('ns:ping', :ns => 'urn:xmpp:ping')).to be_empty
 
-    iq.ping.should_not be_nil
-    iq.xpath('ns:ping', :ns => 'urn:xmpp:ping').should_not be_empty
+    expect(iq.ping).not_to be_nil
+    expect(iq.xpath('ns:ping', :ns => 'urn:xmpp:ping')).not_to be_empty
   end
 
   it 'responds with an empty IQ' do
@@ -39,7 +39,7 @@ describe Blather::Stanza::Iq::Ping do
       pong.from = 'one@example.com'
     end
     reply = ping.reply
-    reply.should == expected_pong
-    reply.children.count.should == 0
+    expect(reply).to eq(expected_pong)
+    expect(reply.children.count).to eq(0)
   end
 end

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Blather::Stanza::Iq::Query do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:query, nil).should == Blather::Stanza::Iq::Query
+    expect(Blather::XMPPNode.class_from_registration(:query, nil)).to eq(Blather::Stanza::Iq::Query)
   end
 
   it 'can be imported' do
@@ -13,52 +13,52 @@ describe Blather::Stanza::Iq::Query do
         </query>
       </iq>
     XML
-    Blather::XMPPNode.parse(string).should be_instance_of Blather::Stanza::Iq::Query
+    expect(Blather::XMPPNode.parse(string)).to 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').should_not be_empty
+    expect(query.xpath('query')).not_to 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').should be_empty
+    expect(query.xpath('query')).to be_empty
 
-    query.query.should_not be_nil
-    query.xpath('query').should_not be_empty
+    expect(query.query).not_to be_nil
+    expect(query.xpath('query')).not_to 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.should == type
+      expect(query.type).to eq(type)
     end
   end
 
   it 'sets type to "result" on reply' do
     query = Blather::Stanza::Iq::Query.new
-    query.type.should == :get
-    reply = query.reply.type.should == :result
+    expect(query.type).to eq(:get)
+    reply = expect(query.reply.type).to eq(:result)
   end
 
   it 'sets type to "result" on reply!' do
     query = Blather::Stanza::Iq::Query.new
-    query.type.should == :get
+    expect(query.type).to eq(:get)
     query.reply!
-    query.type.should == :result
+    expect(query.type).to eq(: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').should == QueryNs
+    expect(Blather::XMPPNode.class_from_registration(:query, 'query:ns')).to eq(QueryNs)
     query_ns = QueryNs.new
-    query_ns.xpath('query').should be_empty
-    query_ns.xpath('ns:query', :ns => 'query:ns').size.should == 1
+    expect(query_ns.xpath('query')).to be_empty
+    expect(query_ns.xpath('ns:query', :ns => 'query:ns').size).to eq(1)
 
     query_ns.query
     query_ns.query
-    query_ns.xpath('ns:query', :ns => 'query:ns').size.should == 1
+    expect(query_ns.xpath('ns:query', :ns => 'query:ns').size).to eq(1)
   end
 end

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

@@ -26,17 +26,17 @@ end
 
 describe Blather::Stanza::Iq::Roster do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:query, 'jabber:iq:roster').should == Blather::Stanza::Iq::Roster
+    expect(Blather::XMPPNode.class_from_registration(:query, 'jabber:iq:roster')).to eq(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.should == [Blather::Stanza::Iq::Roster::RosterItem]
+    expect(r.items.map { |i| i.class }.uniq).to eq([Blather::Stanza::Iq::Roster::RosterItem])
   end
 
   it 'can be created with #import' do
-    Blather::XMPPNode.parse(roster_xml).should be_instance_of Blather::Stanza::Iq::Roster
+    expect(Blather::XMPPNode.parse(roster_xml)).to be_instance_of Blather::Stanza::Iq::Roster
   end
 
   it 'retrieves version' do
@@ -49,22 +49,22 @@ 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.should == Blather::JID.new('n@d/r').stripped
+    expect(i.jid).to eq(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.should == 'foobar'
+    expect(i.name).to eq('foobar')
   end
 
   it 'can be initialized with a subscription' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new nil, nil, :both
-    i.subscription.should == :both
+    expect(i.subscription).to eq(: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.should == :subscribe
+    expect(i.ask).to eq(:subscribe)
   end
 
   it 'can be initailized with a hash' do
@@ -73,10 +73,10 @@ describe Blather::Stanza::Iq::Roster::RosterItem do
                 :subscription => :both,
                 :ask          => :subscribe }
     i = Blather::Stanza::Iq::Roster::RosterItem.new control
-    i.jid.should == Blather::JID.new(control[:jid]).stripped
-    i.name.should == control[:name]
-    i.subscription.should == control[:subscription]
-    i.ask.should == control[:ask]
+    expect(i.jid).to eq(Blather::JID.new(control[:jid]).stripped)
+    expect(i.name).to eq(control[:name])
+    expect(i.subscription).to eq(control[:subscription])
+    expect(i.ask).to eq(control[:ask])
   end
 
   it 'inherits a node when initialized with one' do
@@ -85,61 +85,61 @@ describe Blather::Stanza::Iq::Roster::RosterItem do
     n[:subscription] = 'both'
 
     i = Blather::Stanza::Iq::Roster::RosterItem.new n
-    i.jid.should == Blather::JID.new('n@d/r')
-    i.subscription.should == :both
+    expect(i.jid).to eq(Blather::JID.new('n@d/r'))
+    expect(i.subscription).to eq(: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.should respond_to :groups
-    i.groups.sort.should == %w[bar baz foo]
+    expect(i).to respond_to :groups
+    expect(i.groups.sort).to eq(%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.should respond_to :groups=
-    i.groups.sort.should == %w[bar baz foo]
+    expect(i).to respond_to :groups=
+    expect(i.groups.sort).to eq(%w[bar baz foo])
     i.groups = %w[a b c]
-    i.groups.sort.should == %w[a b c]
+    expect(i.groups.sort).to eq(%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.should respond_to :to_stanza
+    expect(i).to respond_to :to_stanza
     s = i.to_stanza
-    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]
+    expect(s).to be_kind_of Blather::Stanza::Iq::Roster
+    expect(s.items.first.jid).to eq(Blather::JID.new('romeo@example.net'))
+    expect(s.items.first.groups.sort).to eq(%w[bar baz foo])
   end
 
   it 'has an "attr_accessor" for jid' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
-    i.should respond_to :jid
-    i.jid.should be_nil
-    i.should respond_to :jid=
+    expect(i).to respond_to :jid
+    expect(i.jid).to be_nil
+    expect(i).to respond_to :jid=
     i.jid = 'n@d/r'
-    i.jid.should == Blather::JID.new('n@d/r').stripped
+    expect(i.jid).to eq(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.should == 'name'
+    expect(i.name).to eq('name')
   end
 
   it 'has a subscription attribute' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.subscription = :both
-    i.subscription.should == :both
+    expect(i.subscription).to eq(:both)
   end
 
   it 'has an ask attribute' do
     i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.ask = :subscribe
-    i.ask.should == :subscribe
+    expect(i.ask).to eq(:subscribe)
   end
 end

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

@@ -23,35 +23,35 @@ end
 
 describe Blather::Stanza::Iq::S5b do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/bytestreams').should == Blather::Stanza::Iq::S5b
+    expect(Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/bytestreams')).to eq(Blather::Stanza::Iq::S5b)
   end
 
   it 'can be imported' do
     node = Blather::XMPPNode.parse s5b_open_xml
-    node.should be_instance_of Blather::Stanza::Iq::S5b
+    expect(node).to be_instance_of Blather::Stanza::Iq::S5b
   end
 
   it 'can get sid' do
     node = Blather::XMPPNode.parse s5b_open_xml
-    node.sid.should == 'vxf9n471bn46'
+    expect(node.sid).to eq('vxf9n471bn46')
   end
 
   it 'can get streamhosts' do
     node = Blather::XMPPNode.parse s5b_open_xml
-    node.streamhosts.size.should == 2
+    expect(node.streamhosts.size).to eq(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.should == 1
+    expect(node.streamhosts.size).to eq(1)
     node.streamhosts += [Blather::Stanza::Iq::S5b::StreamHost.new('test2@example.com/foo', '192.168.5.2', 123)]
-    node.streamhosts.size.should == 2
+    expect(node.streamhosts.size).to eq(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.should == 'used@example.com/foo'
+    expect(node.streamhost_used.jid.to_s).to eq('used@example.com/foo')
   end
 end

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

@@ -27,27 +27,27 @@ end
 
 describe Blather::Stanza::Iq::Si do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:si, 'http://jabber.org/protocol/si').should == Blather::Stanza::Iq::Si
+    expect(Blather::XMPPNode.class_from_registration(:si, 'http://jabber.org/protocol/si')).to eq(Blather::Stanza::Iq::Si)
   end
 
   it 'can be imported' do
     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
+    expect(node).to be_instance_of Blather::Stanza::Iq::Si
+    expect(node.si).to 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').should_not be_empty
+    expect(iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si')).not_to 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').should be_empty
+    expect(iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si')).to be_empty
 
-    iq.si.should_not be_nil
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').should_not be_empty
+    expect(iq.si).not_to be_nil
+    expect(iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si')).not_to be_empty
   end
 
   it 'ensures a si node is replaced when calling #si=' do
@@ -58,8 +58,8 @@ describe Blather::Stanza::Iq::Si do
 
     iq.si = new_si
 
-    iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').size.should == 1
-    iq.si.id.should == 'a1'
+    expect(iq.xpath('ns:si', :ns => 'http://jabber.org/protocol/si').size).to eq(1)
+    expect(iq.si.id).to eq('a1')
   end
 end
 
@@ -69,30 +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.should == 'a1'
-    si.mime_type.should == 'text/plain'
-    si.profile.should == 'http://jabber.org/protocol/si/profile/file-transfer'
+    expect(si.id).to eq('a1')
+    expect(si.mime_type).to eq('text/plain')
+    expect(si.profile).to eq('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.should == 'test.txt'
-    file.size.should == 123
+    expect(file.name).to eq('test.txt')
+    expect(file.size).to eq(123)
   end
 
   it 'can be initialized with node' do
     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.should == 'test.txt'
-    file.size.should == 1022
+    expect(file.name).to eq('test.txt')
+    expect(file.size).to eq(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.should == 'This is a test. If this were a real file...'
+    expect(file.desc).to eq('This is a test. If this were a real file...')
   end
 end

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

@@ -12,27 +12,27 @@ end
 
 describe Blather::Stanza::Iq::Vcard do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:vCard, 'vcard-temp').should == Blather::Stanza::Iq::Vcard
+    expect(Blather::XMPPNode.class_from_registration(:vCard, 'vcard-temp')).to eq(Blather::Stanza::Iq::Vcard)
   end
 
   it 'can be imported' do
     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
+    expect(query).to be_instance_of Blather::Stanza::Iq::Vcard
+    expect(query.vcard).to 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').should_not be_empty
+    expect(query.xpath('ns:vCard', :ns => 'vcard-temp')).not_to 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').should be_empty
+    expect(query.xpath('ns:vCard', :ns => 'vcard-temp')).to be_empty
 
-    query.vcard.should_not be_nil
-    query.xpath('ns:vCard', :ns => 'vcard-temp').should_not be_empty
+    expect(query.vcard).not_to be_nil
+    expect(query.xpath('ns:vCard', :ns => 'vcard-temp')).not_to be_empty
   end
 
   it 'ensures a vcard node is replaced when calling #vcard=' do
@@ -43,8 +43,8 @@ describe Blather::Stanza::Iq::Vcard do
 
     query.vcard = new_vcard
 
-    query.xpath('ns:vCard', :ns => 'vcard-temp').size.should == 1
-    query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content.should == 'Mercutio'
+    expect(query.xpath('ns:vCard', :ns => 'vcard-temp').size).to eq(1)
+    expect(query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content).to eq('Mercutio')
   end
 end
 
@@ -52,42 +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.should == 'Romeo'
+    expect(query.find_first('ns:vCard/ns:NICKNAME', :ns => 'vcard-temp').content).to eq('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.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
+    expect(query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.size).to eq(2)
+    expect(query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'TYPE' && n.content == 'image/png' }).not_to be_nil
+    expect(query.find_first('ns:vCard/ns:PHOTO', :ns => 'vcard-temp').children.detect { |n| n.element_name == 'BINVAL' && n.content == '====' }).not_to be_nil
   end
 
   it 'can get vcard elements' do
     query = Blather::Stanza::Iq::Vcard.new :set
     query.vcard['NICKNAME'] = 'Romeo'
-    query.vcard['NICKNAME'].should == 'Romeo'
+    expect(query.vcard['NICKNAME']).to eq('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'].should == 'image/png'
-    query.vcard['PHOTO/BINVAL'].should == '===='
+    expect(query.vcard['PHOTO/TYPE']).to eq('image/png')
+    expect(query.vcard['PHOTO/BINVAL']).to eq('====')
   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'].should be_nil
+    expect(query.vcard['FN']).to be_nil
   end
 
   it 'can update vcard elements' do
     query = Blather::XMPPNode.parse vcard_xml
-    query.vcard['NICKNAME'].should == 'Romeo'
+    expect(query.vcard['NICKNAME']).to eq('Romeo')
     query.vcard['NICKNAME'] = 'Mercutio'
-    query.vcard['NICKNAME'].should == 'Mercutio'
+    expect(query.vcard['NICKNAME']).to eq('Mercutio')
   end
 end