blather 1.2.0 → 2.0.0

data/spec/blather/stanza/presence/c_spec.rb

@@ -13,44 +13,44 @@ end
 
 describe 'Blather::Stanza::Presence::C' do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:c, 'http://jabber.org/protocol/caps' ).should == Blather::Stanza::Presence::C
+    expect(Blather::XMPPNode.class_from_registration(:c, 'http://jabber.org/protocol/caps' )).to eq(Blather::Stanza::Presence::C)
   end
 
   it 'must be importable' do
     c = Blather::XMPPNode.parse c_xml
-    c.should be_kind_of Blather::Stanza::Presence::C::InstanceMethods
-    c.hash.should == :'sha-1'
-    c.node.should == 'http://www.chatopus.com'
-    c.ver.should == 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
+    expect(c).to be_kind_of Blather::Stanza::Presence::C::InstanceMethods
+    expect(c.hash).to eq(:'sha-1')
+    expect(c.node).to eq('http://www.chatopus.com')
+    expect(c.ver).to eq('zHyEOgxTrkpSdGcQKH8EFPLsriY=')
   end
 
   it 'ensures hash is one of Blather::Stanza::Presence::C::VALID_HASH_TYPES' do
-    lambda { Blather::Stanza::Presence::C.new nil, nil, :invalid_type_name }.should raise_error(Blather::ArgumentError)
+    expect { Blather::Stanza::Presence::C.new nil, nil, :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Presence::C::VALID_HASH_TYPES.each do |valid_hash|
       c = Blather::Stanza::Presence::C.new nil, nil, valid_hash
-      c.hash.should == valid_hash.to_sym
+      expect(c.hash).to eq(valid_hash.to_sym)
     end
   end
 
   it 'can set a hash on creation' do
     c = Blather::Stanza::Presence::C.new nil, nil, :md5
-    c.hash.should == :md5
+    expect(c.hash).to eq(:md5)
   end
 
   it 'can set a node on creation' do
     c = Blather::Stanza::Presence::C.new 'http://www.chatopus.com'
-    c.node.should == 'http://www.chatopus.com'
+    expect(c.node).to eq('http://www.chatopus.com')
   end
 
   it 'can set a ver on creation' do
     c = Blather::Stanza::Presence::C.new nil, 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
-    c.ver.should == 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
+    expect(c.ver).to eq('zHyEOgxTrkpSdGcQKH8EFPLsriY=')
   end
 
   it 'is equal on import and creation' do
     p = Blather::XMPPNode.parse c_xml
     c = Blather::Stanza::Presence::C.new 'http://www.chatopus.com', 'zHyEOgxTrkpSdGcQKH8EFPLsriY=', 'sha-1'
-    p.should == c
+    expect(p).to eq(c)
   end
 end

data/spec/blather/stanza/presence/muc_spec.rb

@@ -12,26 +12,26 @@ end
 
 describe 'Blather::Stanza::Presence::MUC' do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:x, 'http://jabber.org/protocol/muc' ).should == Blather::Stanza::Presence::MUC
+    expect(Blather::XMPPNode.class_from_registration(:x, 'http://jabber.org/protocol/muc' )).to eq(Blather::Stanza::Presence::MUC)
   end
 
   it 'must be importable' do
     c = Blather::XMPPNode.parse(muc_xml)
-    c.should be_kind_of Blather::Stanza::Presence::MUC::InstanceMethods
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).count.should == 1
+    expect(c).to be_kind_of Blather::Stanza::Presence::MUC::InstanceMethods
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).count).to eq(1)
   end
 
   it 'ensures a form node is present on create' do
     c = Blather::Stanza::Presence::MUC.new
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should_not be_empty
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns)).not_to be_empty
   end
 
   it 'ensures a form node exists when calling #muc' do
     c = Blather::Stanza::Presence::MUC.new
     c.remove_children :x
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should be_empty
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns)).to be_empty
 
-    c.muc.should_not be_nil
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should_not be_empty
+    expect(c.muc).not_to be_nil
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns)).not_to be_empty
   end
 end

data/spec/blather/stanza/presence/muc_user_spec.rb

@@ -20,64 +20,64 @@ end
 describe 'Blather::Stanza::Presence::MUCUser' do
   it 'must be importable' do
     muc_user = Blather::XMPPNode.parse(muc_user_xml)
-    muc_user.should be_kind_of Blather::Stanza::Presence::MUCUser::InstanceMethods
-    muc_user.affiliation.should == :none
-    muc_user.jid.should == 'hag66@shakespeare.lit/pda'
-    muc_user.role.should == :participant
-    muc_user.status_codes.should == [100, 110]
-    muc_user.password.should == 'foobar'
+    expect(muc_user).to be_kind_of Blather::Stanza::Presence::MUCUser::InstanceMethods
+    expect(muc_user.affiliation).to eq(:none)
+    expect(muc_user.jid).to eq('hag66@shakespeare.lit/pda')
+    expect(muc_user.role).to eq(:participant)
+    expect(muc_user.status_codes).to eq([100, 110])
+    expect(muc_user.password).to eq('foobar')
   end
 
   it 'ensures a form node is present on create' do
     c = Blather::Stanza::Presence::MUCUser.new
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should_not be_empty
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns)).not_to be_empty
   end
 
   it 'ensures a form node exists when calling #muc' do
     c = Blather::Stanza::Presence::MUCUser.new
     c.remove_children :x
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should be_empty
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns)).to be_empty
 
-    c.muc_user.should_not be_nil
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should_not be_empty
+    expect(c.muc_user).not_to be_nil
+    expect(c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns)).not_to be_empty
   end
 
   it "must be able to set the affiliation" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.affiliation.should == nil
+    expect(muc_user.affiliation).to eq(nil)
     muc_user.affiliation = :none
-    muc_user.affiliation.should == :none
+    expect(muc_user.affiliation).to eq(:none)
   end
 
   it "must be able to set the role" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.role.should == nil
+    expect(muc_user.role).to eq(nil)
     muc_user.role = :participant
-    muc_user.role.should == :participant
+    expect(muc_user.role).to eq(:participant)
   end
 
   it "must be able to set the jid" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.jid.should == nil
+    expect(muc_user.jid).to eq(nil)
     muc_user.jid = 'foo@bar.com'
-    muc_user.jid.should == 'foo@bar.com'
+    expect(muc_user.jid).to eq('foo@bar.com')
   end
 
   it "must be able to set the status codes" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.status_codes.should == []
+    expect(muc_user.status_codes).to eq([])
     muc_user.status_codes = [100, 110]
-    muc_user.status_codes.should == [100, 110]
+    expect(muc_user.status_codes).to eq([100, 110])
     muc_user.status_codes = [500]
-    muc_user.status_codes.should == [500]
+    expect(muc_user.status_codes).to eq([500])
   end
 
   it "must be able to set the password" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.password.should == nil
+    expect(muc_user.password).to eq(nil)
     muc_user.password = 'barbaz'
-    muc_user.password.should == 'barbaz'
+    expect(muc_user.password).to eq('barbaz')
     muc_user.password = 'hello_world'
-    muc_user.password.should == 'hello_world'
+    expect(muc_user.password).to eq('hello_world')
   end
 end

data/spec/blather/stanza/presence/status_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe Blather::Stanza::Presence::Status do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:status, nil).should == Blather::Stanza::Presence::Status
+    expect(Blather::XMPPNode.class_from_registration(:status, nil)).to eq(Blather::Stanza::Presence::Status)
   end
 
   it 'must be importable as unavailable' do
-    Blather::XMPPNode.parse('<presence type="unavailable"/>').should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    expect(Blather::XMPPNode.parse('<presence type="unavailable"/>')).to be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
   end
 
   it 'must be importable as nil' do
-    Blather::XMPPNode.parse('<presence/>').should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    expect(Blather::XMPPNode.parse('<presence/>')).to be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
   end
 
   it 'must be importable with show, status and priority children' do
@@ -21,83 +21,83 @@ describe Blather::Stanza::Presence::Status do
         <priority>10</priority>
       </presence>
     XML
-    n.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
-    n.state.should == :chat
-    n.message.should == 'Talk to me!'
-    n.priority.should == 10
+    expect(n).to be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    expect(n.state).to eq(:chat)
+    expect(n.message).to eq('Talk to me!')
+    expect(n.priority).to eq(10)
   end
 
   it 'can set state on creation' do
     status = Blather::Stanza::Presence::Status.new :away
-    status.state.should == :away
+    expect(status.state).to eq(:away)
   end
 
   it 'can set a message on creation' do
     status = Blather::Stanza::Presence::Status.new nil, 'Say hello!'
-    status.message.should == 'Say hello!'
+    expect(status.message).to eq('Say hello!')
   end
 
   it 'ensures type is nil or :unavailable' do
     status = Blather::Stanza::Presence::Status.new
-    lambda { status.type = :invalid_type_name }.should raise_error(Blather::ArgumentError)
+    expect { status.type = :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
     [nil, :unavailable].each do |valid_type|
       status.type = valid_type
-      status.type.should == valid_type
+      expect(status.type).to eq(valid_type)
     end
   end
 
   it 'ensures state is one of Presence::Status::VALID_STATES' do
     status = Blather::Stanza::Presence::Status.new
-    lambda { status.state = :invalid_type_name }.should raise_error(Blather::ArgumentError)
+    expect { status.state = :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Presence::Status::VALID_STATES.each do |valid_state|
       status.state = valid_state
-      status.state.should == valid_state
+      expect(status.state).to eq(valid_state)
     end
   end
 
   it 'returns :available if state is nil' do
-    Blather::Stanza::Presence::Status.new.state.should == :available
+    expect(Blather::Stanza::Presence::Status.new.state).to eq(:available)
   end
 
   it 'returns :available if <show/> is blank' do
     status = Blather::XMPPNode.parse(<<-NODE)
       <presence><show/></presence>
     NODE
-    status.state.should == :available
+    expect(status.state).to eq(:available)
   end
 
   it 'returns :unavailable if type is :unavailable' do
     status = Blather::Stanza::Presence::Status.new
     status.type = :unavailable
-    status.state.should == :unavailable
+    expect(status.state).to eq(:unavailable)
   end
 
   it 'ensures priority is not greater than 127' do
-    lambda { Blather::Stanza::Presence::Status.new.priority = 128 }.should raise_error(Blather::ArgumentError)
+    expect { Blather::Stanza::Presence::Status.new.priority = 128 }.to raise_error(Blather::ArgumentError)
   end
 
   it 'ensures priority is not less than -128' do
-    lambda { Blather::Stanza::Presence::Status.new.priority = -129 }.should raise_error(Blather::ArgumentError)
+    expect { Blather::Stanza::Presence::Status.new.priority = -129 }.to raise_error(Blather::ArgumentError)
   end
 
   it 'has "attr_accessor" for priority' do
     status = Blather::Stanza::Presence::Status.new
-    status.priority.should == 0
+    expect(status.priority).to eq(0)
 
     status.priority = 10
-    status.children.detect { |n| n.element_name == 'priority' }.should_not be_nil
-    status.priority.should == 10
+    expect(status.children.detect { |n| n.element_name == 'priority' }).not_to be_nil
+    expect(status.priority).to eq(10)
   end
 
   it 'has "attr_accessor" for message' do
     status = Blather::Stanza::Presence::Status.new
-    status.message.should be_nil
+    expect(status.message).to be_nil
 
     status.message = 'new message'
-    status.children.detect { |n| n.element_name == 'status' }.should_not be_nil
-    status.message.should == 'new message'
+    expect(status.children.detect { |n| n.element_name == 'status' }).not_to be_nil
+    expect(status.message).to eq('new message')
   end
 
   it 'must be comparable by priority' do
@@ -111,11 +111,11 @@ describe Blather::Stanza::Presence::Status do
 
     status1.priority = 1
     status2.priority = -1
-    (status1 <=> status2).should == 1
-    (status2 <=> status1).should == -1
+    expect(status1 <=> status2).to eq(1)
+    expect(status2 <=> status1).to eq(-1)
 
     status2.priority = 1
-    (status1 <=> status2).should == 0
+    expect(status1 <=> status2).to eq(0)
   end
 
   it 'must should sort by status if priorities are equal' do
@@ -128,8 +128,8 @@ describe Blather::Stanza::Presence::Status do
     status2.from = jid
 
     status1.priority = status2.priority = 1
-    (status1 <=> status2).should == -1
-    (status2 <=> status1).should == 1
+    expect(status1 <=> status2).to eq(-1)
+    expect(status2 <=> status1).to eq(1)
   end
 
   it 'raises an argument error if compared to a status with a different Blather::JID' do
@@ -139,20 +139,20 @@ describe Blather::Stanza::Presence::Status do
     status2 = Blather::Stanza::Presence::Status.new
     status2.from = 'd@e/f'
 
-    lambda { status1 <=> status2 }.should raise_error(Blather::ArgumentError)
+    expect { status1 <=> status2 }.to raise_error(Blather::ArgumentError)
   end
 
   ([:available] + Blather::Stanza::Presence::Status::VALID_STATES).each do |valid_state|
     it "provides a helper (#{valid_state}?) for state #{valid_state}" do
-      Blather::Stanza::Presence::Status.new.should respond_to :"#{valid_state}?"
+      expect(Blather::Stanza::Presence::Status.new).to respond_to :"#{valid_state}?"
     end
 
     it "returns true on call to (#{valid_state}?) if state == #{valid_state}" do
       method = "#{valid_state}?".to_sym
       stat = Blather::Stanza::Presence::Status.new
       stat.state = valid_state
-      stat.should respond_to method
-      stat.__send__(method).should == true
+      expect(stat).to respond_to method
+      expect(stat.__send__(method)).to eq(true)
     end
   end
 end

data/spec/blather/stanza/presence/subscription_spec.rb

@@ -2,35 +2,35 @@ require 'spec_helper'
 
 describe Blather::Stanza::Presence::Subscription do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:subscription, nil).should == Blather::Stanza::Presence::Subscription
+    expect(Blather::XMPPNode.class_from_registration(:subscription, nil)).to eq(Blather::Stanza::Presence::Subscription)
   end
 
   [:subscribe, :subscribed, :unsubscribe, :unsubscribed].each do |type|
     it "must be importable as #{type}" do
-      Blather::XMPPNode.parse("<presence type='#{type}'/>").should be_kind_of Blather::Stanza::Presence::Subscription::InstanceMethods
+      expect(Blather::XMPPNode.parse("<presence type='#{type}'/>")).to be_kind_of Blather::Stanza::Presence::Subscription::InstanceMethods
     end
   end
 
   it 'can set to on creation' do
     sub = Blather::Stanza::Presence::Subscription.new 'a@b'
-    sub.to.to_s.should == 'a@b'
+    expect(sub.to.to_s).to eq('a@b')
   end
 
   it 'can set a type on creation' do
     sub = Blather::Stanza::Presence::Subscription.new nil, :subscribed
-    sub.type.should == :subscribed
+    expect(sub.type).to eq(:subscribed)
   end
 
   it 'strips Blather::JIDs when setting #to' do
     sub = Blather::Stanza::Presence::Subscription.new 'a@b/c'
-    sub.to.to_s.should == 'a@b'
+    expect(sub.to.to_s).to eq('a@b')
   end
 
   it 'generates an approval using #approve!' do
     sub = Blather::Stanza.import Nokogiri::XML('<presence from="a@b" type="subscribe"><status/></presence>').root
     sub.approve!
-    sub.to.should == 'a@b'
-    sub.type.should == :subscribed
+    expect(sub.to).to eq('a@b')
+    expect(sub.type).to eq(:subscribed)
   end
 
   it 'generates a refusal using #refuse!' do
@@ -38,8 +38,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.refuse!
-    sub.to.should == jid
-    sub.type.should == :unsubscribed
+    expect(sub.to).to eq(jid)
+    expect(sub.type).to eq(:unsubscribed)
   end
 
   it 'generates an unsubscript using #unsubscribe!' do
@@ -47,8 +47,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.unsubscribe!
-    sub.to.should == jid
-    sub.type.should == :unsubscribe
+    expect(sub.to).to eq(jid)
+    expect(sub.type).to eq(:unsubscribe)
   end
 
   it 'generates a cancellation using #cancel!' do
@@ -56,8 +56,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.cancel!
-    sub.to.should == jid
-    sub.type.should == :unsubscribed
+    expect(sub.to).to eq(jid)
+    expect(sub.type).to eq(:unsubscribed)
   end
 
   it 'generates a request using #request!' do
@@ -65,15 +65,15 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.request!
-    sub.to.should == jid
-    sub.type.should == :subscribe
+    expect(sub.to).to eq(jid)
+    expect(sub.type).to eq(:subscribe)
   end
 
   it 'has a #request? helper' do
     sub = Blather::Stanza::Presence::Subscription.new
-    sub.should respond_to :request?
+    expect(sub).to respond_to :request?
     sub.type = :subscribe
-    sub.request?.should == true
+    expect(sub.request?).to eq(true)
   end
 
   it "successfully routes chained actions" do
@@ -84,9 +84,9 @@ describe Blather::Stanza::Presence::Subscription do
     sub.to = to
     sub.cancel!
     sub.unsubscribe!
-    sub.type.should == :unsubscribe
-    sub.to.should == from
-    sub.from.should == to
+    expect(sub.type).to eq(:unsubscribe)
+    expect(sub.to).to eq(from)
+    expect(sub.from).to eq(to)
   end
 
   it "will inherit only another node's attributes" do
@@ -94,9 +94,9 @@ describe Blather::Stanza::Presence::Subscription do
     inheritable[:bar] = 'baz'
 
     sub = Blather::Stanza::Presence::Subscription.new
-    sub.should respond_to :inherit
+    expect(sub).to respond_to :inherit
 
     sub.inherit inheritable
-    sub[:bar].should == 'baz'
+    expect(sub[:bar]).to eq('baz')
   end
 end