blather 1.2.0 → 2.0.0

data/spec/blather/client/dsl_spec.rb

@@ -109,7 +109,7 @@ describe Blather::DSL do
   it 'provides a << style writer that provides chaining' do
     stanza = Blather::Stanza::Iq.new
     @client.expects(:write).with stanza
-    (@dsl << stanza).should == @dsl
+    expect(@dsl << stanza).to eq(@dsl)
   end
 
   it 'provides a writer' do
@@ -173,7 +173,7 @@ describe Blather::DSL do
   end
 
   it 'provides a caps set helper' do
-    @dsl.should respond_to :set_caps
+    expect(@dsl).to respond_to :set_caps
     node = 'http://code.google.com/p/exodus'
     identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
     features = %w{
@@ -183,13 +183,13 @@ describe Blather::DSL do
                   http://jabber.org/protocol/muc
                 }
     @dsl.set_caps node, identities, features
-    @client.caps.node.should == "#{node}##{@client.caps.ver}"
-    @client.caps.identities.should == identities
-    @client.caps.features.map{ |f| f.var }.should == features
+    expect(@client.caps.node).to eq("#{node}##{@client.caps.ver}")
+    expect(@client.caps.identities).to eq(identities)
+    expect(@client.caps.features.map{ |f| f.var }).to eq(features)
   end
 
   it 'provides a caps send helper' do
-    @dsl.should respond_to :send_caps
+    expect(@dsl).to respond_to :send_caps
     @client.caps.node = 'http://code.google.com/p/exodus'
     @client.caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
     @client.caps.features = %w{
@@ -260,8 +260,8 @@ describe Blather::DSL do
   it 'has a pubsub helper set to the jid domain' do
     jid = Blather::JID.new('jid@domain/resource')
     @client.stubs(:jid).returns jid
-    @dsl.pubsub.should be_instance_of Blather::DSL::PubSub
-    @dsl.pubsub.host.should == jid.domain
+    expect(@dsl.pubsub).to be_instance_of Blather::DSL::PubSub
+    expect(@dsl.pubsub.host).to eq(jid.domain)
   end
 
   context "extending a module" do
@@ -291,7 +291,7 @@ describe Blather::DSL do
 
     it "should override the handlers" do
       target = CollisionTarget.new
-      target.presence.should be :ghostly
+      expect(target.presence).to be :ghostly
     end
   end
 end

data/spec/blather/errors/sasl_error_spec.rb

@@ -10,9 +10,9 @@ end
 
 describe Blather::SASLError do
   it 'can import a node' do
-    Blather::SASLError.should respond_to :import
+    expect(Blather::SASLError).to respond_to :import
     e = Blather::SASLError.import sasl_error_node
-    e.should be_kind_of Blather::SASLError
+    expect(e).to be_kind_of Blather::SASLError
   end
 
   describe 'each XMPP SASL error type' do
@@ -26,7 +26,7 @@ describe Blather::SASLError do
     ].each do |error_type|
       it "handles the name for #{error_type}" do
         e = Blather::SASLError.import sasl_error_node(error_type)
-        e.name.should == error_type.gsub('-','_').to_sym
+        expect(e.name).to eq(error_type.gsub('-','_').to_sym)
       end
     end
   end

data/spec/blather/errors/stanza_error_spec.rb

@@ -24,20 +24,20 @@ end
 
 describe Blather::StanzaError do
   it 'can import a node' do
-    Blather::StanzaError.should respond_to :import
+    expect(Blather::StanzaError).to respond_to :import
     e = Blather::StanzaError.import stanza_error_node
-    e.should be_kind_of Blather::StanzaError
+    expect(e).to be_kind_of Blather::StanzaError
   end
 
   describe 'valid types' do
     before { @original = Blather::Stanza::Message.new 'error@jabber.local', 'test message', :error }
 
     it 'ensures type is one of Stanza::Message::VALID_TYPES' do
-      lambda { Blather::StanzaError.new @original, :gone, :invalid_type_name }.should raise_error(Blather::ArgumentError)
+      expect { Blather::StanzaError.new @original, :gone, :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
       Blather::StanzaError::VALID_TYPES.each do |valid_type|
         msg = Blather::StanzaError.new @original, :gone, valid_type
-        msg.type.should == valid_type
+        expect(msg.type).to eq(valid_type)
       end
     end
   end
@@ -51,48 +51,48 @@ describe Blather::StanzaError do
     end
 
     it 'provides a type attribute' do
-      @err.should respond_to :type
-      @err.type.should == @type.to_sym
+      expect(@err).to respond_to :type
+      expect(@err.type).to eq(@type.to_sym)
     end
 
     it 'provides a name attribute' do
-      @err.should respond_to :name
-      @err.name.should == @err_name.gsub('-','_').to_sym
+      expect(@err).to respond_to :name
+      expect(@err.name).to eq(@err_name.gsub('-','_').to_sym)
     end
 
     it 'provides a text attribute' do
-      @err.should respond_to :text
-      @err.text.should == @msg
+      expect(@err).to respond_to :text
+      expect(@err.text).to eq(@msg)
     end
 
     it 'provides a reader to the original node' do
-      @err.should respond_to :original
-      @err.original.should be_instance_of Blather::Stanza::Message
+      expect(@err).to respond_to :original
+      expect(@err.original).to be_instance_of Blather::Stanza::Message
     end
 
     it 'provides an extras attribute' do
-      @err.should respond_to :extras
-      @err.extras.should be_instance_of Array
-      @err.extras.first.element_name.should == 'extra-error'
+      expect(@err).to respond_to :extras
+      expect(@err.extras).to be_instance_of Array
+      expect(@err.extras.first.element_name).to eq('extra-error')
     end
 
     it 'describes itself' do
-      @err.to_s.should match(/#{@err_name}/)
-      @err.to_s.should match(/#{@msg}/)
+      expect(@err.to_s).to match(/#{@err_name}/)
+      expect(@err.to_s).to match(/#{@msg}/)
 
-      @err.inspect.should match(/#{@err_name}/)
-      @err.inspect.should match(/#{@msg}/)
+      expect(@err.inspect).to match(/#{@err_name}/)
+      expect(@err.inspect).to match(/#{@msg}/)
     end
 
     it 'can be turned into xml' do
-      @err.should respond_to :to_xml
+      expect(@err).to respond_to :to_xml
       doc = parse_stanza @err.to_xml
 
-      doc.xpath("/message[@from='error@jabber.local' and @type='error']").should_not be_empty
-      doc.xpath("/message/error").should_not be_empty
-      doc.xpath("/message/error/err_ns:internal-server-error", :err_ns => Blather::StanzaError::STANZA_ERR_NS).should_not be_empty
-      doc.xpath("/message/error/err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StanzaError::STANZA_ERR_NS).should_not be_empty
-      doc.xpath("/message/error/extra_ns:extra-error[.='Blather Error']", :extra_ns => 'blather:stanza:error').should_not be_empty
+      expect(doc.xpath("/message[@from='error@jabber.local' and @type='error']")).not_to be_empty
+      expect(doc.xpath("/message/error")).not_to be_empty
+      expect(doc.xpath("/message/error/err_ns:internal-server-error", :err_ns => Blather::StanzaError::STANZA_ERR_NS)).not_to be_empty
+      expect(doc.xpath("/message/error/err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StanzaError::STANZA_ERR_NS)).not_to be_empty
+      expect(doc.xpath("/message/error/extra_ns:extra-error[.='Blather Error']", :extra_ns => 'blather:stanza:error')).not_to be_empty
     end
   end
 
@@ -122,7 +122,7 @@ describe Blather::StanzaError do
       ].each do |error_type|
         it "handles the name for #{error_type}" do
           e = Blather::StanzaError.import stanza_error_node(:cancel, error_type)
-          e.name.should == error_type.gsub('-','_').to_sym
+          expect(e.name).to eq(error_type.gsub('-','_').to_sym)
         end
       end
   end

data/spec/blather/errors/stream_error_spec.rb

@@ -23,13 +23,13 @@ end
 describe 'Blather::StreamError' do
   it 'can import a node' do
     err = stream_error_node 'internal-server-error', 'the message'
-    Blather::StreamError.should respond_to :import
+    expect(Blather::StreamError).to respond_to :import
     e = Blather::StreamError.import err
-    e.should be_kind_of Blather::StreamError
+    expect(e).to be_kind_of Blather::StreamError
 
-    e.name.should == :internal_server_error
-    e.text.should == 'the message'
-    e.extras.should == err.find('descendant::*[name()="extra-error"]', 'blather:stream:error').map {|n|n}
+    expect(e.name).to eq(:internal_server_error)
+    expect(e.text).to eq('the message')
+    expect(e.extras).to eq(err.find('descendant::*[name()="extra-error"]', 'blather:stream:error').map {|n|n})
   end
 end
 
@@ -41,36 +41,36 @@ describe 'Blather::StreamError when instantiated' do
   end
 
   it 'provides a err_name attribute' do
-    @err.should respond_to :name
-    @err.name.should == @err_name.gsub('-','_').to_sym
+    expect(@err).to respond_to :name
+    expect(@err.name).to eq(@err_name.gsub('-','_').to_sym)
   end
 
   it 'provides a text attribute' do
-    @err.should respond_to :text
-    @err.text.should == @msg
+    expect(@err).to respond_to :text
+    expect(@err.text).to eq(@msg)
   end
 
   it 'provides an extras attribute' do
-    @err.should respond_to :extras
-    @err.extras.should be_instance_of Array
-    @err.extras.size.should == 1
-    @err.extras.first.element_name.should == 'extra-error'
+    expect(@err).to respond_to :extras
+    expect(@err.extras).to be_instance_of Array
+    expect(@err.extras.size).to eq(1)
+    expect(@err.extras.first.element_name).to eq('extra-error')
   end
 
   it 'describes itself' do
-    @err.to_s.should match(/#{@type}/)
-    @err.to_s.should match(/#{@msg}/)
+    expect(@err.to_s).to match(/#{@type}/)
+    expect(@err.to_s).to match(/#{@msg}/)
 
-    @err.inspect.should match(/#{@type}/)
-    @err.inspect.should match(/#{@msg}/)
+    expect(@err.inspect).to match(/#{@type}/)
+    expect(@err.inspect).to match(/#{@msg}/)
   end
 
   it 'can be turned into xml' do
-    @err.should respond_to :to_xml
+    expect(@err).to respond_to :to_xml
     doc = parse_stanza @err.to_xml
-    doc.xpath("//err_ns:internal-server-error", :err_ns => Blather::StreamError::STREAM_ERR_NS).should_not be_empty
-    doc.xpath("//err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StreamError::STREAM_ERR_NS).should_not be_empty
-    doc.xpath("//err_ns:extra-error[.='Blather Error']", :err_ns => 'blather:stream:error').should_not be_empty
+    expect(doc.xpath("//err_ns:internal-server-error", :err_ns => Blather::StreamError::STREAM_ERR_NS)).not_to be_empty
+    expect(doc.xpath("//err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StreamError::STREAM_ERR_NS)).not_to be_empty
+    expect(doc.xpath("//err_ns:extra-error[.='Blather Error']", :err_ns => 'blather:stream:error')).not_to be_empty
   end
 end
 
@@ -102,7 +102,7 @@ describe 'Each XMPP stream error type' do
     ].each do |error_type|
       it "handles the name for #{error_type}" do
         e = Blather::StreamError.import stream_error_node(error_type)
-        e.name.should == error_type.gsub('-','_').to_sym
+        expect(e.name).to eq(error_type.gsub('-','_').to_sym)
       end
     end
 end

data/spec/blather/errors_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Blather::BlatherError do
   it 'is handled by :error' do
-    Blather::BlatherError.new.handler_hierarchy.should == [:error]
+    expect(Blather::BlatherError.new.handler_hierarchy).to eq([:error])
   end
 end
 
@@ -10,12 +10,12 @@ describe 'Blather::ParseError' do
   before { @error = Blather::ParseError.new('</generate-parse-error>"') }
 
   it 'is registers with the handler hierarchy' do
-    @error.handler_hierarchy.should == [:parse_error, :error]
+    expect(@error.handler_hierarchy).to eq([:parse_error, :error])
   end
 
   it 'contains the error message' do
-    @error.should respond_to :message
-    @error.message.should == '</generate-parse-error>"'
+    expect(@error).to respond_to :message
+    expect(@error.message).to eq('</generate-parse-error>"')
   end
 end
 
@@ -23,11 +23,11 @@ describe 'Blather::UnknownResponse' do
   before { @error = Blather::UnknownResponse.new(Blather::XMPPNode.new('foo-bar')) }
 
   it 'is registers with the handler hierarchy' do
-    @error.handler_hierarchy.should == [:unknown_response_error, :error]
+    expect(@error.handler_hierarchy).to eq([:unknown_response_error, :error])
   end
 
   it 'holds on to a copy of the failure node' do
-    @error.should respond_to :node
-    @error.node.element_name.should == 'foo-bar'
+    expect(@error).to respond_to :node
+    expect(@error.node.element_name).to eq('foo-bar')
   end
 end

data/spec/blather/file_transfer_spec.rb

@@ -47,7 +47,7 @@ describe Blather::FileTransfer do
     iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::Ibb::NS_IBB
+      expect(answer.si.feature.x.field('stream-method').value).to eq(Blather::Stanza::Iq::Ibb::NS_IBB)
       true
     end
 
@@ -61,7 +61,7 @@ describe Blather::FileTransfer do
     iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::S5b::NS_S5B
+      expect(answer.si.feature.x.field('stream-method').value).to eq(Blather::Stanza::Iq::S5b::NS_S5B)
       true
     end
 
@@ -75,7 +75,7 @@ describe Blather::FileTransfer do
     iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::S5b::NS_S5B
+      expect(answer.si.feature.x.field('stream-method').value).to eq(Blather::Stanza::Iq::S5b::NS_S5B)
       true
     end
 
@@ -90,8 +90,8 @@ describe Blather::FileTransfer do
     iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.find_first('error')['type'].should == "cancel"
-      answer.find_first('.//ns:no-valid-streams', :ns => 'http://jabber.org/protocol/si').should_not be_nil
+      expect(answer.find_first('error')['type']).to eq("cancel")
+      expect(answer.find_first('.//ns:no-valid-streams', :ns => 'http://jabber.org/protocol/si')).not_to be_nil
       true
     end
 
@@ -105,9 +105,9 @@ describe Blather::FileTransfer do
     iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.find_first('error')['type'].should == "cancel"
-      answer.find_first('.//ns:forbidden', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas').should_not be_nil
-      answer.find_first('.//ns:text', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas').content.should == "Offer declined"
+      expect(answer.find_first('error')['type']).to eq("cancel")
+      expect(answer.find_first('.//ns:forbidden', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas')).not_to be_nil
+      expect(answer.find_first('.//ns:text', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas').content).to eq("Offer declined")
       true
     end
 
@@ -130,6 +130,6 @@ describe Blather::FileTransfer do
         end
       end
     end
-    lambda { TestS5B.new }.should_not raise_error
+    expect { TestS5B.new }.not_to raise_error
   end
 end

data/spec/blather/jid_spec.rb

@@ -3,85 +3,85 @@ require 'spec_helper'
 describe Blather::JID do
   it 'does nothing if creaded from Blather::JID' do
     jid = Blather::JID.new 'n@d/r'
-    Blather::JID.new(jid).object_id.should == jid.object_id
+    expect(Blather::JID.new(jid).object_id).to eq(jid.object_id)
   end
 
   it 'creates a new Blather::JID from (n,d,r)' do
     jid = Blather::JID.new('n', 'd', 'r')
-    jid.node.should == 'n'
-    jid.domain.should == 'd'
-    jid.resource.should == 'r'
+    expect(jid.node).to eq('n')
+    expect(jid.domain).to eq('d')
+    expect(jid.resource).to eq('r')
   end
 
   it 'creates a new Blather::JID from (n,d)' do
     jid = Blather::JID.new('n', 'd')
-    jid.node.should == 'n'
-    jid.domain.should == 'd'
+    expect(jid.node).to eq('n')
+    expect(jid.domain).to eq('d')
   end
 
   it 'creates a new Blather::JID from (n@d)' do
     jid = Blather::JID.new('n@d')
-    jid.node.should == 'n'
-    jid.domain.should == 'd'
+    expect(jid.node).to eq('n')
+    expect(jid.domain).to eq('d')
   end
 
   it 'creates a new Blather::JID from (n@d/r)' do
     jid = Blather::JID.new('n@d/r')
-    jid.node.should == 'n'
-    jid.domain.should == 'd'
-    jid.resource.should == 'r'
+    expect(jid.node).to eq('n')
+    expect(jid.domain).to eq('d')
+    expect(jid.resource).to eq('r')
   end
 
   it 'requires at least a node' do
-    proc { Blather::JID.new }.should raise_error ::ArgumentError
+    expect { Blather::JID.new }.to raise_error ::ArgumentError
   end
 
   it 'ensures length of node is no more than 1023 characters' do
-    proc { Blather::JID.new('n'*1024) }.should raise_error Blather::ArgumentError
+    expect { Blather::JID.new('n'*1024) }.to raise_error Blather::ArgumentError
   end
 
   it 'ensures length of domain is no more than 1023 characters' do
-    proc { Blather::JID.new('n', 'd'*1024) }.should raise_error Blather::ArgumentError
+    expect { Blather::JID.new('n', 'd'*1024) }.to raise_error Blather::ArgumentError
   end
 
   it 'ensures length of resource is no more than 1023 characters' do
-    proc { Blather::JID.new('n', 'd', 'r'*1024) }.should raise_error Blather::ArgumentError
+    expect { Blather::JID.new('n', 'd', 'r'*1024) }.to raise_error Blather::ArgumentError
   end
 
   it 'compares Blather::JIDs' do
-    (Blather::JID.new('a@b/c') <=> Blather::JID.new('d@e/f')).should == -1
-    (Blather::JID.new('a@b/c') <=> Blather::JID.new('a@b/c')).should == 0
-    (Blather::JID.new('d@e/f') <=> Blather::JID.new('a@b/c')).should == 1
+    expect(Blather::JID.new('a@b/c') <=> Blather::JID.new('d@e/f')).to eq(-1)
+    expect(Blather::JID.new('a@b/c') <=> Blather::JID.new('a@b/c')).to eq(0)
+    expect(Blather::JID.new('d@e/f') <=> Blather::JID.new('a@b/c')).to eq(1)
   end
 
   it 'checks for equality' do
-    (Blather::JID.new('n@d/r') == Blather::JID.new('n@d/r')).should == true
-    Blather::JID.new('n@d/r').eql?(Blather::JID.new('n@d/r')).should == true
+    expect(Blather::JID.new('n@d/r') == Blather::JID.new('n@d/r')).to eq(true)
+    expect(Blather::JID.new('n@d/r').eql?(Blather::JID.new('n@d/r'))).to eq(true)
   end
 
   it 'will strip' do
     jid = Blather::JID.new('n@d/r')
-    jid.stripped.should == Blather::JID.new('n@d')
-    jid.should == Blather::JID.new('n@d/r')
+    expect(jid.stripped).to eq(Blather::JID.new('n@d'))
+    expect(jid).to eq(Blather::JID.new('n@d/r'))
   end
 
   it 'will strip itself' do
     jid = Blather::JID.new('n@d/r')
     jid.strip!
-    jid.should == Blather::JID.new('n@d')
+    expect(jid).to eq(Blather::JID.new('n@d'))
   end
 
   it 'has a string representation' do
-    Blather::JID.new('n@d/r').to_s.should == 'n@d/r'
-    Blather::JID.new('n', 'd', 'r').to_s.should == 'n@d/r'
-    Blather::JID.new('n', 'd').to_s.should == 'n@d'
+    expect(Blather::JID.new('n@d/r').to_s).to eq('n@d/r')
+    expect(Blather::JID.new('n', 'd', 'r').to_s).to eq('n@d/r')
+    expect(Blather::JID.new('n', 'd').to_s).to eq('n@d')
   end
 
   it 'provides a #stripped? helper' do
     jid = Blather::JID.new 'a@b/c'
-    jid.should respond_to :stripped?
-    jid.stripped?.should_not equal true
+    expect(jid).to respond_to :stripped?
+    expect(jid.stripped?).not_to equal true
     jid.strip!
-    jid.stripped?.should == true
+    expect(jid.stripped?).to eq(true)
   end
 end