blather 0.6.2 → 0.7.0

data/spec/blather/stanza/iq_spec.rb

@@ -2,44 +2,44 @@ require 'spec_helper'
 
 describe Blather::Stanza::Iq do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:iq, nil).must_equal Blather::Stanza::Iq
+    Blather::XMPPNode.class_from_registration(:iq, nil).should == Blather::Stanza::Iq
   end
 
   it 'must be importable' do
-    doc = parse_stanza "<iq from='juliet@example.com/balcony' type='set' id='roster_4'></iq>"
-    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq
+    string = "<iq from='juliet@example.com/balcony' type='set' id='roster_4'></iq>"
+    Blather::XMPPNode.parse(string).should be_instance_of Blather::Stanza::Iq
   end
 
   it 'creates a new Iq stanza defaulted as a get' do
-    Blather::Stanza::Iq.new.type.must_equal :get
+    Blather::Stanza::Iq.new.type.should == :get
   end
 
   it 'sets the id when created' do
-    Blather::Stanza::Iq.new.id.wont_be_nil
+    Blather::Stanza::Iq.new.id.should_not be_nil
   end
 
   it 'creates a new Stanza::Iq object on import' do
-    Blather::Stanza::Iq.import(Blather::XMPPNode.new('iq')).must_be_kind_of Blather::Stanza::Iq
+    Blather::Stanza::Iq.import(Blather::XMPPNode.new('iq')).should be_kind_of Blather::Stanza::Iq
   end
 
   it 'creates a proper object based on its children' do
     n = Blather::XMPPNode.new('iq')
     n << Blather::XMPPNode.new('query', n.document)
-    Blather::Stanza::Iq.import(n).must_be_kind_of Blather::Stanza::Iq::Query
+    Blather::Stanza::Iq.import(n).should be_kind_of Blather::Stanza::Iq::Query
   end
 
   it 'ensures type is one of Stanza::Iq::VALID_TYPES' do
-    lambda { Blather::Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Iq.new :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
       n = Blather::Stanza::Iq.new valid_type
-      n.type.must_equal valid_type
+      n.type.should == valid_type
     end
   end
 
   Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Blather::Stanza::Iq.new.must_respond_to :"#{valid_type}?"
+      Blather::Stanza::Iq.new.should respond_to :"#{valid_type}?"
     end
   end
 
@@ -48,7 +48,7 @@ describe Blather::Stanza::Iq do
     iq.from = 'them@example.com'
     iq << Blather::XMPPNode.new('query', iq.document)
     r = iq.reply
-    r.children.empty?.must_equal true
+    r.children.empty?.should == true
   end
 
   it 'does not remove the body when replying if we ask to keep it' do
@@ -56,6 +56,6 @@ describe Blather::Stanza::Iq do
     iq.from = 'them@example.com'
     iq << Blather::XMPPNode.new('query', iq.document)
     r = iq.reply :remove_children => false
-    r.children.empty?.must_equal false
+    r.children.empty?.should == false
   end
 end

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

@@ -38,115 +38,115 @@ end
 describe 'Blather::Stanza::Message::MUCUser' do
   it 'ensures a form node is present on create' do
     c = Blather::Stanza::Message::MUCUser.new
-    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).wont_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).should_not be_empty
   end
 
   it 'ensures a form node exists when calling #muc' do
     c = Blather::Stanza::Message::MUCUser.new
     c.remove_children :x
-    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).must_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).should be_empty
 
-    c.muc_user.wont_be_nil
-    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).wont_be_empty
+    c.muc_user.should_not be_nil
+    c.xpath('ns:x', :ns => Blather::Stanza::Message::MUCUser.registered_ns).should_not be_empty
   end
 
   it 'ensures the message type is :normal' do
     m = Blather::Stanza::Message::MUCUser.new
-    m.normal?.must_equal true
+    m.normal?.should == true
   end
 
   it "must be able to set the password" do
     muc_user = Blather::Stanza::Message::MUCUser.new
-    muc_user.password.must_equal nil
+    muc_user.password.should == nil
     muc_user.password = 'barbaz'
-    muc_user.password.must_equal 'barbaz'
+    muc_user.password.should == 'barbaz'
     muc_user.password = 'hello_world'
-    muc_user.password.must_equal 'hello_world'
+    muc_user.password.should == 'hello_world'
   end
 
   it "should not be an #invite?" do
     muc_user = Blather::Stanza::Message::MUCUser.new
-    muc_user.invite?.must_equal false
+    muc_user.invite?.should == false
   end
 
   describe "with an invite element" do
     it "should be an #invite?" do
-      muc_user = Blather::XMPPNode.import(parse_stanza(muc_invite_xml).root)
-      muc_user.invite?.must_equal true
+      muc_user = Blather::XMPPNode.parse(muc_invite_xml)
+      muc_user.invite?.should == true
     end
 
     it "should know the invite attributes properly" do
-      muc_user = Blather::XMPPNode.import(parse_stanza(muc_invite_xml).root)
-      muc_user.must_be_instance_of Blather::Stanza::Message::MUCUser
+      muc_user = Blather::XMPPNode.parse(muc_invite_xml)
+      muc_user.should be_instance_of Blather::Stanza::Message::MUCUser
       invite = muc_user.invite
-      invite.to.must_equal 'hecate@shakespeare.lit'
-      invite.from.must_equal 'crone1@shakespeare.lit/desktop'
-      invite.reason.must_equal 'Hey Hecate, this is the place for all good witches!'
-      muc_user.password.must_equal 'foobar'
+      invite.to.should == 'hecate@shakespeare.lit'
+      invite.from.should == 'crone1@shakespeare.lit/desktop'
+      invite.reason.should == 'Hey Hecate, this is the place for all good witches!'
+      muc_user.password.should == 'foobar'
     end
 
     it "must be able to set the to jid" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       invite = muc_user.invite
-      invite.to.must_equal nil
+      invite.to.should == nil
       invite.to = 'foo@bar.com'
-      invite.to.must_equal 'foo@bar.com'
+      invite.to.should == 'foo@bar.com'
     end
 
     it "must be able to set the from jid" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       invite = muc_user.invite
-      invite.from.must_equal nil
+      invite.from.should == nil
       invite.from = 'foo@bar.com'
-      invite.from.must_equal 'foo@bar.com'
+      invite.from.should == 'foo@bar.com'
     end
 
     it "must be able to set the reason" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       invite = muc_user.invite
-      invite.reason.must_equal ''
+      invite.reason.should == ''
       invite.reason = 'Please join'
-      invite.reason.must_equal 'Please join'
+      invite.reason.should == 'Please join'
     end
   end
 
   describe "with a decline element" do
     it "should be an #invite_decline?" do
-      muc_user = Blather::XMPPNode.import(parse_stanza(muc_decline_xml).root)
-      muc_user.must_be_instance_of Blather::Stanza::Message::MUCUser
-      muc_user.invite_decline?.must_equal true
+      muc_user = Blather::XMPPNode.parse(muc_decline_xml)
+      muc_user.should be_instance_of Blather::Stanza::Message::MUCUser
+      muc_user.invite_decline?.should == true
     end
 
     it "should know the decline attributes properly" do
-      muc_user = Blather::XMPPNode.import(parse_stanza(muc_decline_xml).root)
+      muc_user = Blather::XMPPNode.parse(muc_decline_xml)
       decline = muc_user.decline
-      decline.to.must_equal 'crone1@shakespeare.lit'
-      decline.from.must_equal 'hecate@shakespeare.lit'
-      decline.reason.must_equal "Sorry, I'm too busy right now."
+      decline.to.should == 'crone1@shakespeare.lit'
+      decline.from.should == 'hecate@shakespeare.lit'
+      decline.reason.should == "Sorry, I'm too busy right now."
     end
 
     it "must be able to set the to jid" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       decline = muc_user.decline
-      decline.to.must_equal nil
+      decline.to.should == nil
       decline.to = 'foo@bar.com'
-      decline.to.must_equal 'foo@bar.com'
+      decline.to.should == 'foo@bar.com'
     end
 
     it "must be able to set the from jid" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       decline = muc_user.decline
-      decline.from.must_equal nil
+      decline.from.should == nil
       decline.from = 'foo@bar.com'
-      decline.from.must_equal 'foo@bar.com'
+      decline.from.should == 'foo@bar.com'
     end
 
     it "must be able to set the reason" do
       muc_user = Blather::Stanza::Message::MUCUser.new
       decline = muc_user.decline
-      decline.reason.must_equal ''
+      decline.reason.should == ''
       decline.reason = 'Please join'
-      decline.reason.must_equal 'Please join'
+      decline.reason.should == 'Please join'
     end
   end
 end

data/spec/blather/stanza/message_spec.rb

@@ -70,67 +70,67 @@ end
 
 describe Blather::Stanza::Message do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:message, nil).must_equal Blather::Stanza::Message
+    Blather::XMPPNode.class_from_registration(:message, nil).should == Blather::Stanza::Message
   end
 
   it 'must be importable' do
-    Blather::XMPPNode.import(parse_stanza(message_xml).root).must_be_instance_of Blather::Stanza::Message
-    Blather::XMPPNode.import(parse_stanza(ichat_message_xml).root).must_be_instance_of Blather::Stanza::Message
+    Blather::XMPPNode.parse(message_xml).should be_instance_of Blather::Stanza::Message
+    Blather::XMPPNode.parse(ichat_message_xml).should be_instance_of Blather::Stanza::Message
   end
 
   it 'provides "attr_accessor" for body' do
     s = Blather::Stanza::Message.new
-    s.body.must_be_nil
-    s.find('body').must_be_empty
+    s.body.should be_nil
+    s.find('body').should be_empty
 
     s.body = 'test message'
-    s.body.wont_be_nil
-    s.find('body').wont_be_empty
+    s.body.should_not be_nil
+    s.find('body').should_not be_empty
   end
 
   it 'provides "attr_accessor" for subject' do
     s = Blather::Stanza::Message.new
-    s.subject.must_be_nil
-    s.find('subject').must_be_empty
+    s.subject.should be_nil
+    s.find('subject').should be_empty
 
     s.subject = 'test subject'
-    s.subject.wont_be_nil
-    s.find('subject').wont_be_empty
+    s.subject.should_not be_nil
+    s.find('subject').should_not be_empty
   end
 
   it 'provides "attr_accessor" for thread' do
     s = Blather::Stanza::Message.new
-    s.thread.must_be_nil
-    s.find('thread').must_be_empty
+    s.thread.should be_nil
+    s.find('thread').should be_empty
 
     s.thread = 1234
-    s.thread.wont_be_nil
-    s.find('thread').wont_be_empty
+    s.thread.should_not be_nil
+    s.find('thread').should_not be_empty
   end
 
   it 'can set a parent attribute for thread' do
     s = Blather::Stanza::Message.new
-    s.thread.must_be_nil
-    s.find('thread').must_be_empty
+    s.thread.should be_nil
+    s.find('thread').should be_empty
 
     s.thread = {4321 => 1234}
-    s.thread.must_equal '1234'
-    s.parent_thread.must_equal '4321'
-    s.find('thread[@parent="4321"]').wont_be_empty
+    s.thread.should == '1234'
+    s.parent_thread.should == '4321'
+    s.find('thread[@parent="4321"]').should_not be_empty
   end
 
   it 'ensures type is one of Blather::Stanza::Message::VALID_TYPES' do
-    lambda { Blather::Stanza::Message.new nil, nil, :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Message.new nil, nil, :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Message::VALID_TYPES.each do |valid_type|
       msg = Blather::Stanza::Message.new nil, nil, valid_type
-      msg.type.must_equal valid_type
+      msg.type.should == valid_type
     end
   end
 
   Blather::Stanza::Message::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Blather::Stanza::Message.new.must_respond_to :"#{valid_type}?"
+      Blather::Stanza::Message.new.should respond_to :"#{valid_type}?"
     end
   end
 
@@ -140,10 +140,10 @@ describe Blather::Stanza::Message do
       {:html_ns => Blather::Stanza::Message::HTML_NS}
     ]
     msg = Blather::Stanza::Message.new
-    msg.find_first(*search_args).must_be_nil
+    msg.find_first(*search_args).should be_nil
 
     msg.xhtml_node
-    msg.find_first(*search_args).wont_be_nil
+    msg.find_first(*search_args).should_not be_nil
   end
 
   it 'ensures a body node exists when asked for xhtml_node' do
@@ -153,10 +153,10 @@ describe Blather::Stanza::Message do
       :body_ns => Blather::Stanza::Message::HTML_BODY_NS}
     ]
     msg = Blather::Stanza::Message.new
-    msg.find_first(*search_args).must_be_nil
+    msg.find_first(*search_args).should be_nil
 
     msg.xhtml_node
-    msg.find_first(*search_args).wont_be_nil
+    msg.find_first(*search_args).should_not be_nil
   end
 
   it 'returns an existing node when asked for xhtml_node' do
@@ -167,46 +167,46 @@ describe Blather::Stanza::Message do
     b.namespace = Blather::Stanza::Message::HTML_BODY_NS
     h << b
 
-    msg.xhtml_node.must_equal(b)
+    msg.xhtml_node.should ==(b)
   end
 
   it 'has an xhtml setter' do
     msg = Blather::Stanza::Message.new
     xhtml = "<some>xhtml</some>"
     msg.xhtml = xhtml
-    msg.xhtml_node.inner_html.strip.must_equal(xhtml)
+    msg.xhtml_node.inner_html.strip.should ==(xhtml)
   end
 
   it 'sets valid xhtml even if the input is not valid' do
     msg = Blather::Stanza::Message.new
     xhtml = "<some>xhtml"
     msg.xhtml = xhtml
-    msg.xhtml_node.inner_html.strip.must_equal("<some>xhtml</some>")
+    msg.xhtml_node.inner_html.strip.should ==("<some>xhtml</some>")
   end
 
   it 'sets xhtml with more than one root node' do
     msg = Blather::Stanza::Message.new
     xhtml = "<i>xhtml</i> more xhtml"
     msg.xhtml = xhtml
-    msg.xhtml_node.inner_html.strip.must_equal("<i>xhtml</i> more xhtml")
+    msg.xhtml_node.inner_html.strip.should ==("<i>xhtml</i> more xhtml")
   end
 
   it 'has an xhtml getter' do
     msg = Blather::Stanza::Message.new
     xhtml = "<some>xhtml</some>"
     msg.xhtml = xhtml
-    msg.xhtml.must_equal(xhtml)
+    msg.xhtml.should ==(xhtml)
   end
 
   it 'finds xhtml body when html wrapper has wrong namespace' do
-    msg = Blather::XMPPNode.import(parse_stanza(ichat_message_xml).root)
-    msg.xhtml.must_equal "<span style=\"font-family: 'Arial';font-size: 12px;color: #262626;\">Hello</span>\n  <img alt=\"f5ad3a04d218d7160fa02415e02d41b3.jpg\" src=\"message-attachments:1\" width=\"30\" height=\"30\"></img>"
+    msg = Blather::XMPPNode.parse(ichat_message_xml)
+    msg.xhtml.should == "<span style=\"font-family: 'Arial';font-size: 12px;color: #262626;\">Hello</span>\n  <img alt=\"f5ad3a04d218d7160fa02415e02d41b3.jpg\" src=\"message-attachments:1\" width=\"30\" height=\"30\"></img>"
   end
 
   it 'has a chat state setter' do
     msg = Blather::Stanza::Message.new
     msg.chat_state = :composing
-    msg.xpath('ns:composing', :ns => Blather::Stanza::Message::CHAT_STATE_NS).wont_be_empty
+    msg.xpath('ns:composing', :ns => Blather::Stanza::Message::CHAT_STATE_NS).should_not be_empty
   end
 
   it 'will only add one chat state at a time' do
@@ -214,69 +214,69 @@ describe Blather::Stanza::Message do
     msg.chat_state = :composing
     msg.chat_state = :paused
 
-    msg.xpath('ns:*', :ns => Blather::Stanza::Message::CHAT_STATE_NS).size.must_equal(1)
+    msg.xpath('ns:*', :ns => Blather::Stanza::Message::CHAT_STATE_NS).size.should ==(1)
   end
 
   it 'ensures chat state setter accepts strings' do
     msg = Blather::Stanza::Message.new
     msg.chat_state = "gone"
-    msg.xpath('ns:gone', :ns => Blather::Stanza::Message::CHAT_STATE_NS).wont_be_empty
+    msg.xpath('ns:gone', :ns => Blather::Stanza::Message::CHAT_STATE_NS).should_not be_empty
   end
 
   it 'ensures chat state is one of Blather::Stanza::Message::VALID_CHAT_STATES' do
     lambda do
       msg = Blather::Stanza::Message.new
       msg.chat_state = :invalid_chat_state
-    end.must_raise(Blather::ArgumentError)
+    end.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Message::VALID_CHAT_STATES.each do |valid_chat_state|
       msg = Blather::Stanza::Message.new
       msg.chat_state = valid_chat_state
-      msg.chat_state.must_equal valid_chat_state
+      msg.chat_state.should == valid_chat_state
     end
   end
 
   it 'has a chat state getter' do
     msg = Blather::Stanza::Message.new
     msg.chat_state = :paused
-    msg.chat_state.must_equal(:paused)
+    msg.chat_state.should ==(:paused)
   end
 
   it 'imports correct chat state' do
-    Blather::XMPPNode.import(parse_stanza(message_xml).root).chat_state.must_equal :paused
+    Blather::XMPPNode.parse(message_xml).chat_state.should == :paused
   end
 
   it 'makes a form child available' do
-    n = Blather::XMPPNode.import(parse_stanza(message_xml).root)
-    n.form.fields.size.must_equal 1
-    n.form.fields.map { |f| f.class }.uniq.must_equal [Blather::Stanza::X::Field]
-    n.form.must_be_instance_of Blather::Stanza::X
+    n = Blather::XMPPNode.parse(message_xml)
+    n.form.fields.size.should == 1
+    n.form.fields.map { |f| f.class }.uniq.should == [Blather::Stanza::X::Field]
+    n.form.should be_instance_of Blather::Stanza::X
 
     r = Blather::Stanza::Message.new
     r.form.type = :form
-    r.form.type.must_equal :form
+    r.form.type.should == :form
   end
 
   it 'ensures the form child is a direct child' do
     r = Blather::Stanza::Message.new
     r.form
-    r.xpath('ns:x', :ns => Blather::Stanza::X.registered_ns).wont_be_empty
+    r.xpath('ns:x', :ns => Blather::Stanza::X.registered_ns).should_not be_empty
   end
 
   it 'is not delayed' do
-    n = Blather::XMPPNode.import(parse_stanza(message_xml).root)
-    n.delay.must_equal nil
-    n.delayed?.must_equal false
+    n = Blather::XMPPNode.parse(message_xml)
+    n.delay.should == nil
+    n.delayed?.should == false
   end
 
   describe "with a delay" do
     it "is delayed" do
-      n = Blather::XMPPNode.import(parse_stanza(delayed_message_xml).root)
-      n.delayed?.must_equal true
-      n.delay.must_be_instance_of Blather::Stanza::Message::Delay
-      n.delay.from.must_equal 'coven@chat.shakespeare.lit'
-      n.delay.stamp.must_equal Time.utc(2002, 10, 13, 23, 58, 37, 0)
-      n.delay.description.must_equal "Too slow"
+      n = Blather::XMPPNode.parse(delayed_message_xml)
+      n.delayed?.should == true
+      n.delay.should be_instance_of Blather::Stanza::Message::Delay
+      n.delay.from.should == 'coven@chat.shakespeare.lit'
+      n.delay.stamp.should == Time.utc(2002, 10, 13, 23, 58, 37, 0)
+      n.delay.description.should == "Too slow"
     end
   end
 end