blather 0.6.2 → 0.7.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).must_equal @dsl
+    (@dsl << stanza).should == @dsl
   end
 
   it 'provides a writer' do
@@ -153,7 +153,7 @@ describe Blather::DSL do
   end
 
   it 'provides a caps set helper' do
-    @dsl.must_respond_to :set_caps
+    @dsl.should 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{
@@ -163,13 +163,13 @@ describe Blather::DSL do
                   http://jabber.org/protocol/muc
                 }
     @dsl.set_caps node, identities, features
-    @client.caps.node.must_equal "#{node}##{@client.caps.ver}"
-    @client.caps.identities.must_equal identities
-    @client.caps.features.map{ |f| f.var }.must_equal features
+    @client.caps.node.should == "#{node}##{@client.caps.ver}"
+    @client.caps.identities.should == identities
+    @client.caps.features.map{ |f| f.var }.should == features
   end
 
   it 'provides a caps send helper' do
-    @dsl.must_respond_to :send_caps
+    @dsl.should 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{
@@ -178,7 +178,7 @@ describe Blather::DSL do
                           http://jabber.org/protocol/disco#items
                           http://jabber.org/protocol/muc
                         }
-    expected_stanza = Blather::Stanza.import(parse_stanza(<<-XML).root)
+    expected_stanza = Blather::Stanza.parse(<<-XML)
       <presence>
         <c xmlns="http://jabber.org/protocol/caps" hash="sha-1"
            node="http://code.google.com/p/exodus"
@@ -209,9 +209,9 @@ describe Blather::DSL do
                node='http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0='/>
       </iq>
     XML
-    @stanza = Blather::Stanza.import(parse_stanza(stanza).root)
+    @stanza = Blather::Stanza.parse(stanza)
 
-    expected_stanza = Blather::Stanza.import(parse_stanza(<<-XML).root)
+    expected_stanza = Blather::Stanza.parse(<<-XML)
       <iq type="result" id="disco1" to="juliet@capulet.lit/chamber">
         <query xmlns="http://jabber.org/protocol/disco#info" node="http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0=">
           <identity name="Exodus 0.9.1" category="client" type="pc"/>
@@ -240,7 +240,7 @@ 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.must_be_instance_of Blather::DSL::PubSub
-    @dsl.pubsub.host.must_equal jid.domain
+    @dsl.pubsub.should be_instance_of Blather::DSL::PubSub
+    @dsl.pubsub.host.should == jid.domain
   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.must_respond_to :import
+    Blather::SASLError.should respond_to :import
     e = Blather::SASLError.import sasl_error_node
-    e.must_be_kind_of Blather::SASLError
+    e.should 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.must_equal error_type.gsub('-','_').to_sym
+        e.name.should == 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.must_respond_to :import
+    Blather::StanzaError.should respond_to :import
     e = Blather::StanzaError.import stanza_error_node
-    e.must_be_kind_of Blather::StanzaError
+    e.should 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 }.must_raise(Blather::ArgumentError)
+      lambda { Blather::StanzaError.new @original, :gone, :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
       Blather::StanzaError::VALID_TYPES.each do |valid_type|
         msg = Blather::StanzaError.new @original, :gone, valid_type
-        msg.type.must_equal valid_type
+        msg.type.should == valid_type
       end
     end
   end
@@ -51,48 +51,48 @@ describe Blather::StanzaError do
     end
 
     it 'provides a type attribute' do
-      @err.must_respond_to :type
-      @err.type.must_equal @type.to_sym
+      @err.should respond_to :type
+      @err.type.should == @type.to_sym
     end
 
     it 'provides a name attribute' do
-      @err.must_respond_to :name
-      @err.name.must_equal @err_name.gsub('-','_').to_sym
+      @err.should respond_to :name
+      @err.name.should == @err_name.gsub('-','_').to_sym
     end
 
     it 'provides a text attribute' do
-      @err.must_respond_to :text
-      @err.text.must_equal @msg
+      @err.should respond_to :text
+      @err.text.should == @msg
     end
 
     it 'provides a reader to the original node' do
-      @err.must_respond_to :original
-      @err.original.must_be_instance_of Blather::Stanza::Message
+      @err.should respond_to :original
+      @err.original.should be_instance_of Blather::Stanza::Message
     end
 
     it 'provides an extras attribute' do
-      @err.must_respond_to :extras
-      @err.extras.must_be_instance_of Array
-      @err.extras.first.element_name.must_equal 'extra-error'
+      @err.should respond_to :extras
+      @err.extras.should be_instance_of Array
+      @err.extras.first.element_name.should == 'extra-error'
     end
 
     it 'describes itself' do
-      @err.to_s.must_match(/#{@err_name}/)
-      @err.to_s.must_match(/#{@msg}/)
+      @err.to_s.should match(/#{@err_name}/)
+      @err.to_s.should match(/#{@msg}/)
 
-      @err.inspect.must_match(/#{@err_name}/)
-      @err.inspect.must_match(/#{@msg}/)
+      @err.inspect.should match(/#{@err_name}/)
+      @err.inspect.should match(/#{@msg}/)
     end
 
     it 'can be turned into xml' do
-      @err.must_respond_to :to_xml
+      @err.should respond_to :to_xml
       doc = parse_stanza @err.to_xml
 
-      doc.xpath("/message[@from='error@jabber.local' and @type='error']").wont_be_empty
-      doc.xpath("/message/error").wont_be_empty
-      doc.xpath("/message/error/err_ns:internal-server-error", :err_ns => Blather::StanzaError::STANZA_ERR_NS).wont_be_empty
-      doc.xpath("/message/error/err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StanzaError::STANZA_ERR_NS).wont_be_empty
-      doc.xpath("/message/error/extra_ns:extra-error[.='Blather Error']", :extra_ns => 'blather:stanza:error').wont_be_empty
+      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
     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.must_equal error_type.gsub('-','_').to_sym
+          e.name.should == 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.must_respond_to :import
+    Blather::StreamError.should respond_to :import
     e = Blather::StreamError.import err
-    e.must_be_kind_of Blather::StreamError
+    e.should be_kind_of Blather::StreamError
 
-    e.name.must_equal :internal_server_error
-    e.text.must_equal 'the message'
-    e.extras.must_equal err.find('descendant::*[name()="extra-error"]', 'blather:stream:error').map {|n|n}
+    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}
   end
 end
 
@@ -41,36 +41,36 @@ describe 'Blather::StreamError when instantiated' do
   end
 
   it 'provides a err_name attribute' do
-    @err.must_respond_to :name
-    @err.name.must_equal @err_name.gsub('-','_').to_sym
+    @err.should respond_to :name
+    @err.name.should == @err_name.gsub('-','_').to_sym
   end
 
   it 'provides a text attribute' do
-    @err.must_respond_to :text
-    @err.text.must_equal @msg
+    @err.should respond_to :text
+    @err.text.should == @msg
   end
 
   it 'provides an extras attribute' do
-    @err.must_respond_to :extras
-    @err.extras.must_be_instance_of Array
-    @err.extras.size.must_equal 1
-    @err.extras.first.element_name.must_equal 'extra-error'
+    @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'
   end
 
   it 'describes itself' do
-    @err.to_s.must_match(/#{@type}/)
-    @err.to_s.must_match(/#{@msg}/)
+    @err.to_s.should match(/#{@type}/)
+    @err.to_s.should match(/#{@msg}/)
 
-    @err.inspect.must_match(/#{@type}/)
-    @err.inspect.must_match(/#{@msg}/)
+    @err.inspect.should match(/#{@type}/)
+    @err.inspect.should match(/#{@msg}/)
   end
 
   it 'can be turned into xml' do
-    @err.must_respond_to :to_xml
+    @err.should respond_to :to_xml
     doc = parse_stanza @err.to_xml
-    doc.xpath("//err_ns:internal-server-error", :err_ns => Blather::StreamError::STREAM_ERR_NS).wont_be_empty
-    doc.xpath("//err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StreamError::STREAM_ERR_NS).wont_be_empty
-    doc.xpath("//err_ns:extra-error[.='Blather Error']", :err_ns => 'blather:stream:error').wont_be_empty
+    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
   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.must_equal error_type.gsub('-','_').to_sym
+        e.name.should == 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.must_equal [:error]
+    Blather::BlatherError.new.handler_hierarchy.should == [: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.must_equal [:parse_error, :error]
+    @error.handler_hierarchy.should == [:parse_error, :error]
   end
 
   it 'contains the error message' do
-    @error.must_respond_to :message
-    @error.message.must_equal '</generate-parse-error>"'
+    @error.should respond_to :message
+    @error.message.should == '</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.must_equal [:unknown_response_error, :error]
+    @error.handler_hierarchy.should == [:unknown_response_error, :error]
   end
 
   it 'holds on to a copy of the failure node' do
-    @error.must_respond_to :node
-    @error.node.element_name.must_equal 'foo-bar'
+    @error.should respond_to :node
+    @error.node.element_name.should == 'foo-bar'
   end
 end

data/spec/blather/file_transfer_spec.rb

@@ -44,10 +44,10 @@ describe Blather::FileTransfer do
   end
 
   it 'can select ibb' do
-    iq = Blather::XMPPNode.import(parse_stanza(si_xml).root)
+    iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.must_equal Blather::Stanza::Iq::Ibb::NS_IBB
+      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::Ibb::NS_IBB
       true
     end
 
@@ -58,10 +58,10 @@ describe Blather::FileTransfer do
   end
 
   it 'can select s5b' do
-    iq = Blather::XMPPNode.import(parse_stanza(si_xml).root)
+    iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.must_equal Blather::Stanza::Iq::S5b::NS_S5B
+      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::S5b::NS_S5B
       true
     end
 
@@ -70,12 +70,12 @@ describe Blather::FileTransfer do
     transfer.allow_ibb = false
     transfer.accept(MockFileReceiver)
   end
-  
+
   it 'can allow s5b private ips' do
-    iq = Blather::XMPPNode.import(parse_stanza(si_xml).root)
+    iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.si.feature.x.field('stream-method').value.must_equal Blather::Stanza::Iq::S5b::NS_S5B
+      answer.si.feature.x.field('stream-method').value.should == Blather::Stanza::Iq::S5b::NS_S5B
       true
     end
 
@@ -87,11 +87,11 @@ describe Blather::FileTransfer do
   end
 
   it 'can response no-valid-streams' do
-    iq = Blather::XMPPNode.import(parse_stanza(si_xml).root)
+    iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.find_first('error')['type'].must_equal "cancel"
-      answer.find_first('.//ns:no-valid-streams', :ns => 'http://jabber.org/protocol/si').wont_be_nil
+      answer.find_first('error')['type'].should == "cancel"
+      answer.find_first('.//ns:no-valid-streams', :ns => 'http://jabber.org/protocol/si').should_not be_nil
       true
     end
 
@@ -102,19 +102,19 @@ describe Blather::FileTransfer do
   end
 
   it 'can decline transfer' do
-    iq = Blather::XMPPNode.import(parse_stanza(si_xml).root)
+    iq = Blather::XMPPNode.parse(si_xml)
 
     @client.stubs(:write).with do |answer|
-      answer.find_first('error')['type'].must_equal "cancel"
-      answer.find_first('.//ns:forbidden', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas').wont_be_nil
-      answer.find_first('.//ns:text', :ns => 'urn:ietf:params:xml:ns:xmpp-stanzas').content.must_equal "Offer declined"
+      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"
       true
     end
 
     transfer = Blather::FileTransfer.new(@client, iq)
     transfer.decline
   end
-  
+
   it 'can s5b post_init include the handler' do
     class TestS5B < Blather::FileTransfer::S5b::SocketConnection
       def initialize()
@@ -130,8 +130,6 @@ describe Blather::FileTransfer do
         end
       end
     end
-    assert_nothing_raised do
-      TestS5B.new()
-    end
+    lambda { TestS5B.new }.should_not 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.must_equal jid.object_id
+    Blather::JID.new(jid).object_id.should == jid.object_id
   end
 
   it 'creates a new Blather::JID from (n,d,r)' do
     jid = Blather::JID.new('n', 'd', 'r')
-    jid.node.must_equal 'n'
-    jid.domain.must_equal 'd'
-    jid.resource.must_equal 'r'
+    jid.node.should == 'n'
+    jid.domain.should == 'd'
+    jid.resource.should == 'r'
   end
 
   it 'creates a new Blather::JID from (n,d)' do
     jid = Blather::JID.new('n', 'd')
-    jid.node.must_equal 'n'
-    jid.domain.must_equal 'd'
+    jid.node.should == 'n'
+    jid.domain.should == 'd'
   end
 
   it 'creates a new Blather::JID from (n@d)' do
     jid = Blather::JID.new('n@d')
-    jid.node.must_equal 'n'
-    jid.domain.must_equal 'd'
+    jid.node.should == 'n'
+    jid.domain.should == 'd'
   end
 
   it 'creates a new Blather::JID from (n@d/r)' do
     jid = Blather::JID.new('n@d/r')
-    jid.node.must_equal 'n'
-    jid.domain.must_equal 'd'
-    jid.resource.must_equal 'r'
+    jid.node.should == 'n'
+    jid.domain.should == 'd'
+    jid.resource.should == 'r'
   end
 
   it 'requires at least a node' do
-    proc { Blather::JID.new }.must_raise ::ArgumentError
+    proc { Blather::JID.new }.should raise_error ::ArgumentError
   end
 
   it 'ensures length of node is no more than 1023 characters' do
-    proc { Blather::JID.new('n'*1024) }.must_raise Blather::ArgumentError
+    proc { Blather::JID.new('n'*1024) }.should raise_error Blather::ArgumentError
   end
 
   it 'ensures length of domain is no more than 1023 characters' do
-    proc { Blather::JID.new('n', 'd'*1024) }.must_raise Blather::ArgumentError
+    proc { Blather::JID.new('n', 'd'*1024) }.should 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) }.must_raise Blather::ArgumentError
+    proc { Blather::JID.new('n', 'd', 'r'*1024) }.should raise_error Blather::ArgumentError
   end
 
   it 'compares Blather::JIDs' do
-    (Blather::JID.new('a@b/c') <=> Blather::JID.new('d@e/f')).must_equal -1
-    (Blather::JID.new('a@b/c') <=> Blather::JID.new('a@b/c')).must_equal 0
-    (Blather::JID.new('d@e/f') <=> Blather::JID.new('a@b/c')).must_equal 1
+    (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
   end
 
   it 'checks for equality' do
-    (Blather::JID.new('n@d/r') == Blather::JID.new('n@d/r')).must_equal true
-    Blather::JID.new('n@d/r').eql?(Blather::JID.new('n@d/r')).must_equal true
+    (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
   end
 
   it 'will strip' do
     jid = Blather::JID.new('n@d/r')
-    jid.stripped.must_equal Blather::JID.new('n@d')
-    jid.must_equal Blather::JID.new('n@d/r')
+    jid.stripped.should == Blather::JID.new('n@d')
+    jid.should == Blather::JID.new('n@d/r')
   end
 
   it 'will strip itself' do
     jid = Blather::JID.new('n@d/r')
     jid.strip!
-    jid.must_equal Blather::JID.new('n@d')
+    jid.should == Blather::JID.new('n@d')
   end
 
   it 'has a string representation' do
-    Blather::JID.new('n@d/r').to_s.must_equal 'n@d/r'
-    Blather::JID.new('n', 'd', 'r').to_s.must_equal 'n@d/r'
-    Blather::JID.new('n', 'd').to_s.must_equal 'n@d'
+    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'
   end
 
   it 'provides a #stripped? helper' do
     jid = Blather::JID.new 'a@b/c'
-    jid.must_respond_to :stripped?
-    jid.stripped?.wont_equal true
+    jid.should respond_to :stripped?
+    jid.stripped?.should_not equal true
     jid.strip!
-    jid.stripped?.must_equal true
+    jid.stripped?.should == true
   end
 end