spec/blather/stanza/message_spec.rb in blather-1.2.0 vs spec/blather/stanza/message_spec.rb in blather-2.0.0

@@ -68,216 +68,215 @@
   XML
 end
 
 describe Blather::Stanza::Message do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:message, nil).should == Blather::Stanza::Message
+    expect(Blather::XMPPNode.class_from_registration(:message, nil)).to eq(Blather::Stanza::Message)
   end
 
   it 'must be importable' do
-    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
+    expect(Blather::XMPPNode.parse(message_xml)).to be_instance_of Blather::Stanza::Message
+    expect(Blather::XMPPNode.parse(ichat_message_xml)).to be_instance_of Blather::Stanza::Message
   end
 
   it 'provides "attr_accessor" for body' do
     s = Blather::Stanza::Message.new
-    s.body.should be_nil
-    s.find('body').should be_empty
+    expect(s.body).to be_nil
+    expect(s.find('body')).to be_empty
 
     s.body = 'test message'
-    s.body.should_not be_nil
-    s.find('body').should_not be_empty
+    expect(s.body).not_to be_nil
+    expect(s.find('body')).not_to be_empty
   end
 
   it 'provides "attr_accessor" for subject' do
     s = Blather::Stanza::Message.new
-    s.subject.should be_nil
-    s.find('subject').should be_empty
+    expect(s.subject).to be_nil
+    expect(s.find('subject')).to be_empty
 
     s.subject = 'test subject'
-    s.subject.should_not be_nil
-    s.find('subject').should_not be_empty
+    expect(s.subject).not_to be_nil
+    expect(s.find('subject')).not_to be_empty
   end
 
   it 'provides "attr_accessor" for thread' do
     s = Blather::Stanza::Message.new
-    s.thread.should be_nil
-    s.find('thread').should be_empty
+    expect(s.thread).to be_nil
+    expect(s.find('thread')).to be_empty
 
     s.thread = 1234
-    s.thread.should_not be_nil
-    s.find('thread').should_not be_empty
+    expect(s.thread).not_to be_nil
+    expect(s.find('thread')).not_to be_empty
   end
 
   it 'can set a parent attribute for thread' do
     s = Blather::Stanza::Message.new
-    s.thread.should be_nil
-    s.find('thread').should be_empty
+    expect(s.thread).to be_nil
+    expect(s.find('thread')).to be_empty
 
     s.thread = {4321 => 1234}
-    s.thread.should == '1234'
-    s.parent_thread.should == '4321'
-    s.find('thread[@parent="4321"]').should_not be_empty
+    expect(s.thread).to eq('1234')
+    expect(s.parent_thread).to eq('4321')
+    expect(s.find('thread[@parent="4321"]')).not_to 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 }.should raise_error(Blather::ArgumentError)
+    expect { Blather::Stanza::Message.new nil, nil, :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Message::VALID_TYPES.each do |valid_type|
       msg = Blather::Stanza::Message.new nil, nil, valid_type
-      msg.type.should == valid_type
+      expect(msg.type).to eq(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.should respond_to :"#{valid_type}?"
+      expect(Blather::Stanza::Message.new).to respond_to :"#{valid_type}?"
     end
   end
 
   it 'ensures an html node exists when asked for xhtml_node' do
     search_args = [
       '/message/html_ns:html',
       {:html_ns => Blather::Stanza::Message::HTML_NS}
     ]
     msg = Blather::Stanza::Message.new
-    msg.find_first(*search_args).should be_nil
+    expect(msg.find_first(*search_args)).to be_nil
 
     msg.xhtml_node
-    msg.find_first(*search_args).should_not be_nil
+    expect(msg.find_first(*search_args)).not_to be_nil
   end
 
   it 'ensures a body node exists when asked for xhtml_node' do
     search_args = [
       '/message/html_ns:html/body_ns:body',
       {:html_ns => Blather::Stanza::Message::HTML_NS,
       :body_ns => Blather::Stanza::Message::HTML_BODY_NS}
     ]
     msg = Blather::Stanza::Message.new
-    msg.find_first(*search_args).should be_nil
+    expect(msg.find_first(*search_args)).to be_nil
 
     msg.xhtml_node
-    msg.find_first(*search_args).should_not be_nil
+    expect(msg.find_first(*search_args)).not_to be_nil
   end
 
   it 'returns an existing node when asked for xhtml_node' do
     msg = Blather::Stanza::Message.new
     msg << (h = Blather::XMPPNode.new('html', msg.document))
     h.namespace = Blather::Stanza::Message::HTML_NS
     b = Blather::XMPPNode.new('body', msg.document)
     b.namespace = Blather::Stanza::Message::HTML_BODY_NS
     h << b
 
-    msg.xhtml_node.should ==(b)
+    expect(msg.xhtml_node).to eq(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.should ==(xhtml)
+    expect(msg.xhtml_node.inner_html.strip).to eq(xhtml)
   end
 
   it 'sets valid xhtml even if the input is not valid' do
-    pending "Nokogiri doesn't handle invalid HTML on JRuby" if jruby?
     msg = Blather::Stanza::Message.new
     xhtml = "<some>xhtml"
     msg.xhtml = xhtml
-    msg.xhtml_node.inner_html.strip.should == "<some>xhtml</some>"
+    expect(msg.xhtml_node.inner_html.strip).to eq("<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.should ==("<i>xhtml</i> more xhtml")
+    expect(msg.xhtml_node.inner_html.strip).to eq("<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.should ==(xhtml)
+    expect(msg.xhtml).to eq(xhtml)
   end
 
   it 'finds xhtml body when html wrapper has wrong namespace' do
     msg = Blather::XMPPNode.parse(ichat_message_xml)
-    Nokogiri::XML(msg.xhtml).to_xml.should == Nokogiri::XML("<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>").to_xml
+    expect(Nokogiri::XML(msg.xhtml).to_xml).to eq(Nokogiri::XML("<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>").to_xml)
   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).should_not be_empty
+    expect(msg.xpath('ns:composing', :ns => Blather::Stanza::Message::CHAT_STATE_NS)).not_to be_empty
   end
 
   it 'will only add one chat state at a time' do
     msg = Blather::Stanza::Message.new
     msg.chat_state = :composing
     msg.chat_state = :paused
 
-    msg.xpath('ns:*', :ns => Blather::Stanza::Message::CHAT_STATE_NS).size.should ==(1)
+    expect(msg.xpath('ns:*', :ns => Blather::Stanza::Message::CHAT_STATE_NS).size).to eq(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).should_not be_empty
+    expect(msg.xpath('ns:gone', :ns => Blather::Stanza::Message::CHAT_STATE_NS)).not_to be_empty
   end
 
   it 'ensures chat state is one of Blather::Stanza::Message::VALID_CHAT_STATES' do
-    lambda do
+    expect do
       msg = Blather::Stanza::Message.new
       msg.chat_state = :invalid_chat_state
-    end.should raise_error(Blather::ArgumentError)
+    end.to 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.should == valid_chat_state
+      expect(msg.chat_state).to eq(valid_chat_state)
     end
   end
 
   it 'has a chat state getter' do
     msg = Blather::Stanza::Message.new
     msg.chat_state = :paused
-    msg.chat_state.should ==(:paused)
+    expect(msg.chat_state).to eq(:paused)
   end
 
   it 'imports correct chat state' do
-    Blather::XMPPNode.parse(message_xml).chat_state.should == :paused
+    expect(Blather::XMPPNode.parse(message_xml).chat_state).to eq(:paused)
   end
 
   it 'makes a form child available' do
     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
+    expect(n.form.fields.size).to eq(1)
+    expect(n.form.fields.map { |f| f.class }.uniq).to eq([Blather::Stanza::X::Field])
+    expect(n.form).to be_instance_of Blather::Stanza::X
 
     r = Blather::Stanza::Message.new
     r.form.type = :form
-    r.form.type.should == :form
+    expect(r.form.type).to eq(: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).should_not be_empty
+    expect(r.xpath('ns:x', :ns => Blather::Stanza::X.registered_ns)).not_to be_empty
   end
 
   it 'is not delayed' do
     n = Blather::XMPPNode.parse(message_xml)
-    n.delay.should == nil
-    n.delayed?.should == false
+    expect(n.delay).to eq(nil)
+    expect(n.delayed?).to eq(false)
   end
 
   describe "with a delay" do
     it "is delayed" do
       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 == '[e-mail]'
-      n.delay.stamp.should == Time.utc(2002, 10, 13, 23, 58, 37, 0)
-      n.delay.description.should == "Too slow"
+      expect(n.delayed?).to eq(true)
+      expect(n.delay).to be_instance_of Blather::Stanza::Message::Delay
+      expect(n.delay.from).to eq('[e-mail]')
+      expect(n.delay.stamp).to eq(Time.utc(2002, 10, 13, 23, 58, 37, 0))
+      expect(n.delay.description).to eq("Too slow")
     end
   end
 end