blather 1.2.0 → 2.0.0

data/spec/blather/roster_item_spec.rb

@@ -4,68 +4,68 @@ describe Blather::RosterItem do
   it 'can be initialized with Blather::JID' do
     jid = Blather::JID.new(jid)
     i = Blather::RosterItem.new jid
-    i.jid.should == jid
+    expect(i.jid).to eq(jid)
   end
 
   it 'can be initialized with an Iq::RosterItem' do
     jid = 'n@d/r'
     i = Blather::RosterItem.new Blather::Stanza::Iq::Roster::RosterItem.new(jid)
-    i.jid.should == Blather::JID.new(jid).stripped
+    expect(i.jid).to eq(Blather::JID.new(jid).stripped)
   end
 
   it 'can be initialized with a string' do
     jid = 'n@d/r'
     i = Blather::RosterItem.new jid
-    i.jid.should == Blather::JID.new(jid).stripped
+    expect(i.jid).to eq(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).should be control
+    expect(Blather::RosterItem.new(control)).to be 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.should == jid.stripped
+    expect(i.jid).to eq(jid.stripped)
   end
 
   it 'has a subscription setter that forces a symbol' do
     i = Blather::RosterItem.new nil
     i.subscription = 'remove'
-    i.subscription.should == :remove
+    expect(i.subscription).to eq(:remove)
   end
 
   it 'forces the type of subscription' do
-    proc { Blather::RosterItem.new(nil).subscription = 'foo' }.should raise_error Blather::ArgumentError
+    expect { Blather::RosterItem.new(nil).subscription = 'foo' }.to raise_error Blather::ArgumentError
   end
 
   it 'returns :none if the subscription field is blank' do
-    Blather::RosterItem.new(nil).subscription.should == :none
+    expect(Blather::RosterItem.new(nil).subscription).to eq(:none)
   end
 
   it 'ensure #ask is a symbol' do
     i = Blather::RosterItem.new(nil)
     i.ask = 'subscribe'
-    i.ask.should == :subscribe
+    expect(i.ask).to eq(:subscribe)
   end
 
   it 'forces #ask to be :subscribe or nothing at all' do
-    proc { Blather::RosterItem.new(nil).ask = 'foo' }.should raise_error Blather::ArgumentError
+    expect { Blather::RosterItem.new(nil).ask = 'foo' }.to raise_error Blather::ArgumentError
   end
 
   it 'generates a stanza with #to_stanza' do
     jid = Blather::JID.new('n@d/r')
     i = Blather::RosterItem.new jid
     s = i.to_stanza
-    s.should be_kind_of Blather::Stanza::Iq::Roster
-    s.items.first.jid.should == jid.stripped
+    expect(s).to be_kind_of Blather::Stanza::Iq::Roster
+    expect(s.items.first.jid).to eq(jid.stripped)
   end
 
   it 'returns status based on priority' do
     setup_item_with_presences
-    @i.status.should == @p3
+    expect(@i.status).to eq(@p3)
   end
 
   it 'returns status based on priority and state' do
@@ -77,12 +77,12 @@ describe Blather::RosterItem do
     @p4.priority = 15
     @i.status = @p4
 
-    @i.status.should == @p3
+    expect(@i.status).to eq(@p3)
   end
 
   it 'returns status based on resource' do
     setup_item_with_presences
-    @i.status('a').should == @p
+    expect(@i.status('a')).to eq(@p)
   end
 
   def setup_item_with_presences
@@ -116,12 +116,12 @@ describe Blather::RosterItem do
       @i.status = p
     end
 
-    @i.statuses.size.should == 4
+    expect(@i.statuses.size).to eq(4)
   end
 
   it 'initializes groups to [nil] if the item is not part of a group' do
     i = Blather::RosterItem.new 'n@d'
-    i.groups.should == [nil]
+    expect(i.groups).to eq([nil])
   end
 
   it 'can determine equality' do
@@ -129,6 +129,6 @@ describe Blather::RosterItem do
     item2 = Blather::RosterItem.new 'n@d'
     item1.groups = %w[group1 group2]
     item2.groups = %w[group1 group2]
-    (item1 == item2).should == true
+    expect(item1 == item2).to eq(true)
   end
 end

data/spec/blather/roster_spec.rb

@@ -14,31 +14,31 @@ describe Blather::Roster do
   end
 
   it 'initializes with items' do
-    @roster.items.map { |_,i| i.jid.to_s }.should == (@stanza.items.map { |i| i.jid.stripped.to_s }.uniq)
+    expect(@roster.items.map { |_,i| i.jid.to_s }).to eq(@stanza.items.map { |i| i.jid.stripped.to_s }.uniq)
   end
 
   it 'processes @stanzas with remove requests' do
     s = @roster['n@d/0r']
     s.subscription = :remove
-    proc { @roster.process(s.to_stanza) }.should change(@roster, :length).by -1
+    expect { @roster.process(s.to_stanza) }.to change(@roster, :length).by -1
   end
 
   it 'processes @stanzas with add requests' do
     s = Blather::Stanza::Iq::Roster::RosterItem.new('a@b/c').to_stanza
-    proc { @roster.process(s) }.should change(@roster, :length).by 1
+    expect { @roster.process(s) }.to change(@roster, :length).by 1
   end
 
   it 'allows a jid to be pushed' do
     jid = 'a@b/c'
-    proc { @roster.push(jid) }.should change(@roster, :length).by 1
-    @roster[jid].should_not be_nil
+    expect { @roster.push(jid) }.to change(@roster, :length).by 1
+    expect(@roster[jid]).not_to be_nil
   end
 
   it 'allows an item to be pushed' do
     jid = 'a@b/c'
     item = Blather::RosterItem.new(Blather::JID.new(jid))
-    proc { @roster.push(item) }.should change(@roster, :length).by 1
-    @roster[jid].should_not be_nil
+    expect { @roster.push(item) }.to change(@roster, :length).by 1
+    expect(@roster[jid]).not_to be_nil
   end
 
   it 'aliases #<< to #push and returns self to allow for chaining' do
@@ -46,9 +46,9 @@ describe Blather::Roster do
     item = Blather::RosterItem.new(Blather::JID.new(jid))
     jid2 = 'd@e/f'
     item2 = Blather::RosterItem.new(Blather::JID.new(jid2))
-    proc { @roster << item << item2 }.should change(@roster, :length).by 2
-    @roster[jid].should_not be_nil
-    @roster[jid2].should_not be_nil
+    expect { @roster << item << item2 }.to change(@roster, :length).by 2
+    expect(@roster[jid]).not_to be_nil
+    expect(@roster[jid2]).not_to be_nil
   end
 
   it 'sends a @roster addition over the wire' do
@@ -58,7 +58,7 @@ describe Blather::Roster do
   end
 
   it 'removes a Blather::JID' do
-    proc { @roster.delete 'n@d' }.should change(@roster, :length).by -1
+    expect { @roster.delete 'n@d' }.to change(@roster, :length).by -1
   end
 
   it 'sends a @roster removal over the wire' do
@@ -69,26 +69,26 @@ describe Blather::Roster do
 
   it 'returns an item through []' do
     item = @roster['n@d']
-    item.should be_kind_of Blather::RosterItem
-    item.jid.should == Blather::JID.new('n@d')
+    expect(item).to be_kind_of Blather::RosterItem
+    expect(item.jid).to eq(Blather::JID.new('n@d'))
   end
 
   it 'responds to #each' do
-    @roster.should respond_to :each
+    expect(@roster).to respond_to :each
   end
 
   it 'cycles through all the items using #each' do
-    @roster.map { |i| i }.sort.should ==(@roster.items.values.sort)
+    expect(@roster.map { |i| i }.sort).to eq(@roster.items.values.sort)
   end
 
   it 'yields RosterItems from #each' do
-    @roster.map { |i| i.should be_kind_of Blather::RosterItem }
+    @roster.map { |i| expect(i).to be_kind_of Blather::RosterItem }
   end
 
   it 'returns a duplicate of items through #items' do
     items = @roster.items
     items.delete 'n@d'
-    items.should_not equal @roster.items
+    expect(items).not_to equal @roster.items
   end
 
   it 'will group roster items' do
@@ -99,7 +99,7 @@ describe Blather::Roster do
     item2.groups = ['group1', 'group3']
     @roster << item1 << item2
 
-    @roster.grouped.should ==({
+    expect(@roster.grouped).to eq({
       'group1' => [item1, item2],
       'group2' => [item1],
       'group3' => [item2]

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

@@ -21,60 +21,60 @@ 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
+    expect(Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#info')).to eq(Blather::Stanza::Iq::DiscoInfo)
   end
 
   it 'must be importable' do
-    Blather::XMPPNode.parse(disco_info_xml).should be_instance_of Blather::Stanza::Iq::DiscoInfo
+    expect(Blather::XMPPNode.parse(disco_info_xml)).to 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'
+    expect(n.node).to eq('music')
     n.node = :foo
-    n.node.should == 'foo'
+    expect(n.node).to eq('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]
+    expect(r.identities.size).to eq(1)
+    expect(r.identities.map { |i| i.class }.uniq).to eq([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]
+    expect(r.features.size).to eq(2)
+    expect(r.features.map { |i| i.class }.uniq).to eq([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
+    expect(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)).not_to be_empty
   end
 
   it 'allows adding of identities' do
     di = Blather::Stanza::Iq::DiscoInfo.new
-    di.identities.size.should == 0
+    expect(di.identities.size).to eq(0)
     di.identities = [{:name => 'name', :type => 'type', :category => 'category'}]
-    di.identities.size.should == 1
+    expect(di.identities.size).to eq(1)
     di.identities += [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
-    di.identities.size.should == 2
+    expect(di.identities.size).to eq(2)
     di.identities = nil
-    di.identities.size.should == 0
+    expect(di.identities.size).to eq(0)
   end
 
   it 'allows adding of features' do
     di = Blather::Stanza::Iq::DiscoInfo.new
-    di.features.size.should == 0
+    expect(di.features.size).to eq(0)
     di.features = ["feature1"]
-    di.features.size.should == 1
+    expect(di.features.size).to eq(1)
     di.features += [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
-    di.features.size.should == 2
+    expect(di.features.size).to eq(2)
     di.features = nil
-    di.features.size.should == 0
+    expect(di.features.size).to eq(0)
   end
 
 end
@@ -90,8 +90,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 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 }
+    expect(di.identities.size).to eq(2)
+    di.identities.each { |i| expect(control.include?(i)).to eq(true) }
   end
 
   it 'takes a list of Identity objects as identities' do
@@ -99,24 +99,24 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 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 }
+    expect(di.identities.size).to eq(2)
+    di.identities.each { |i| expect(control.include?(i)).to eq(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 }
+    expect(di.identities.size).to eq(1)
+    di.identities.each { |i| expect(control.include?(i)).to eq(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 }
+    expect(di.identities.size).to eq(1)
+    di.identities.each { |i| expect(control.include?(i)).to eq(true) }
   end
 
   it 'takes a mix of hashes and identity objects as identities' do
@@ -129,8 +129,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 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 }
+    expect(di.identities.size).to eq(2)
+    di.identities.each { |i| expect(control.include?(i)).to eq(true) }
   end
 end
 
@@ -140,8 +140,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     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 }
+    expect(di.features.size).to eq(3)
+    di.features.each { |f| expect(control.include?(f)).to eq(true) }
   end
 
   it 'takes a list of features as Feature objects' do
@@ -149,24 +149,24 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     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 }
+    expect(di.features.size).to eq(3)
+    di.features.each { |f| expect(control.include?(f)).to eq(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 }
+    expect(di.features.size).to eq(1)
+    di.features.each { |f| expect(control.include?(f)).to eq(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 }
+    expect(di.features.size).to eq(1)
+    di.features.each { |f| expect(control.include?(f)).to eq(true) }
   end
 
   it 'takes a mixed list of features as Feature objects and strings' do
@@ -175,8 +175,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     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 }
+    expect(di.features.size).to eq(3)
+    di.features.each { |f| expect(control.include?(f)).to eq(true) }
   end
 end
 
@@ -184,44 +184,44 @@ 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'
+    expect(i.name).to eq('Personal Events')
+    expect(i.type).to eq(:pep)
+    expect(i.category).to eq(:pubsub)
+    expect(i.xml_lang).to eq('en')
   end
 
   it 'has a category attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.category.should == :cat
+    expect(n.category).to eq(:cat)
     n.category = :foo
-    n.category.should == :foo
+    expect(n.category).to eq(:foo)
   end
 
   it 'has a type attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.type.should == :type
+    expect(n.type).to eq(:type)
     n.type = :foo
-    n.type.should == :foo
+    expect(n.type).to eq(:foo)
   end
 
   it 'has a name attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.name.should == 'name'
+    expect(n.name).to eq('name')
     n.name = :foo
-    n.name.should == 'foo'
+    expect(n.name).to eq('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'
+    expect(n.xml_lang).to eq('en')
     n.xml_lang = 'de'
-    n.xml_lang.should == 'de'
+    expect(n.xml_lang).to eq('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])
+    expect(a).to eq(Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat]))
+    expect(a).not_to equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[not-name not-type not-cat])
   end
 end
 
@@ -229,19 +229,19 @@ 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'
+    expect(i.var).to eq('ipv6')
   end
 
   it 'has a var attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Feature.new 'var'
-    n.var.should == 'var'
+    expect(n.var).to eq('var')
     n.var = :foo
-    n.var.should == 'foo'
+    expect(n.var).to eq('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')
+    expect(a).to eq(Blather::Stanza::Iq::DiscoInfo::Feature.new('var'))
+    expect(a).not_to equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
   end
 end