blather 1.2.0 → 2.0.0

data/spec/blather/stanza/pubsub/unsubscribe_spec.rb

@@ -3,72 +3,72 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Unsubscribe do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:unsubscribe, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Unsubscribe
+    expect(Blather::XMPPNode.class_from_registration(:unsubscribe, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub::Unsubscribe)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(unsubscribe_xml).should be_instance_of Blather::Stanza::PubSub::Unsubscribe
+    expect(Blather::XMPPNode.parse(unsubscribe_xml)).to be_instance_of Blather::Stanza::PubSub::Unsubscribe
   end
 
   it 'ensures an unsubscribe node is present on create' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node', 'jid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures an unsubscribe node exists when calling #unsubscribe' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node', 'jid'
     unsubscribe.pubsub.remove_children :unsubscribe
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
-    unsubscribe.unsubscribe.should_not be_nil
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(unsubscribe.unsubscribe).not_to be_nil
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node', 'jid'
-    unsubscribe.type.should == :set
+    expect(unsubscribe.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'pubsub.jabber.local', 'node', 'jid'
-    unsubscribe.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(unsubscribe.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node-name', 'jid'
-    unsubscribe.node.should == 'node-name'
+    expect(unsubscribe.node).to eq('node-name')
   end
 
   it 'has a node attribute' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node-name', 'jid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.node.should == 'node-name'
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.node).to eq('node-name')
 
     unsubscribe.node = 'new-node'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@node="new-node"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.node.should == 'new-node'
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@node="new-node"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.node).to eq('new-node')
   end
 
   it 'has a jid attribute' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node-name', 'jid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@jid="jid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.jid.should == Blather::JID.new('jid')
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@jid="jid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.jid).to eq(Blather::JID.new('jid'))
 
     unsubscribe.jid = Blather::JID.new('n@d/r')
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@jid="n@d/r"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.jid.should == Blather::JID.new('n@d/r')
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@jid="n@d/r"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.jid).to eq(Blather::JID.new('n@d/r'))
   end
 
   it 'has a subid attribute' do
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node-name', 'jid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
     unsubscribe = Blather::Stanza::PubSub::Unsubscribe.new :set, 'host', 'node-name', 'jid', 'subid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.subid.should == 'subid'
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.subid).to eq('subid')
 
     unsubscribe.subid = 'newsubid'
-    unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="newsubid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    unsubscribe.subid.should == 'newsubid'
+    expect(unsubscribe.find('//ns:pubsub/ns:unsubscribe[@subid="newsubid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(unsubscribe.subid).to eq('newsubid')
   end
 end

data/spec/blather/stanza/pubsub_owner/delete_spec.rb

@@ -3,11 +3,11 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSubOwner::Delete do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:delete, 'http://jabber.org/protocol/pubsub#owner').should == Blather::Stanza::PubSubOwner::Delete
+    expect(Blather::XMPPNode.class_from_registration(:delete, 'http://jabber.org/protocol/pubsub#owner')).to eq(Blather::Stanza::PubSubOwner::Delete)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(<<-NODE).should be_instance_of Blather::Stanza::PubSubOwner::Delete
+    expect(Blather::XMPPNode.parse(<<-NODE)).to be_instance_of Blather::Stanza::PubSubOwner::Delete
     <iq type='set'
         from='hamlet@denmark.lit/elsinore'
         to='pubsub.shakespeare.lit'
@@ -21,30 +21,30 @@ describe Blather::Stanza::PubSubOwner::Delete do
 
   it 'ensures an delete node is present on delete' do
     delete = Blather::Stanza::PubSubOwner::Delete.new
-    delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_empty
+    expect(delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_empty
   end
 
   it 'ensures an delete node exists when calling #delete_node' do
     delete = Blather::Stanza::PubSubOwner::Delete.new
     delete.pubsub.remove_children :delete
-    delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns).should be_empty
+    expect(delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns)).to be_empty
 
-    delete.delete_node.should_not be_nil
-    delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_empty
+    expect(delete.delete_node).not_to be_nil
+    expect(delete.find('//ns:pubsub/ns:delete', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     delete = Blather::Stanza::PubSubOwner::Delete.new
-    delete.type.should == :set
+    expect(delete.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     delete = Blather::Stanza::PubSubOwner::Delete.new :set, 'pubsub.jabber.local'
-    delete.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(delete.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     delete = Blather::Stanza::PubSubOwner::Delete.new :set, 'host', 'node-name'
-    delete.node.should == 'node-name'
+    expect(delete.node).to eq('node-name')
   end
 end

data/spec/blather/stanza/pubsub_owner/purge_spec.rb

@@ -3,11 +3,11 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSubOwner::Purge do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:purge, 'http://jabber.org/protocol/pubsub#owner').should == Blather::Stanza::PubSubOwner::Purge
+    expect(Blather::XMPPNode.class_from_registration(:purge, 'http://jabber.org/protocol/pubsub#owner')).to eq(Blather::Stanza::PubSubOwner::Purge)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(<<-NODE).should be_instance_of Blather::Stanza::PubSubOwner::Purge
+    expect(Blather::XMPPNode.parse(<<-NODE)).to be_instance_of Blather::Stanza::PubSubOwner::Purge
     <iq type='set'
         from='hamlet@denmark.lit/elsinore'
         to='pubsub.shakespeare.lit'
@@ -21,30 +21,30 @@ describe Blather::Stanza::PubSubOwner::Purge do
 
   it 'ensures an purge node is present on create' do
     purge = Blather::Stanza::PubSubOwner::Purge.new
-    purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_empty
+    expect(purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_empty
   end
 
   it 'ensures an purge node exists when calling #purge_node' do
     purge = Blather::Stanza::PubSubOwner::Purge.new
     purge.pubsub.remove_children :purge
-    purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns).should be_empty
+    expect(purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns)).to be_empty
 
-    purge.purge_node.should_not be_nil
-    purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_empty
+    expect(purge.purge_node).not_to be_nil
+    expect(purge.find('//ns:pubsub/ns:purge', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     purge = Blather::Stanza::PubSubOwner::Purge.new
-    purge.type.should == :set
+    expect(purge.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     purge = Blather::Stanza::PubSubOwner::Purge.new :set, 'pubsub.jabber.local'
-    purge.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(purge.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     purge = Blather::Stanza::PubSubOwner::Purge.new :set, 'host', 'node-name'
-    purge.node.should == 'node-name'
+    expect(purge.node).to eq('node-name')
   end
 end

data/spec/blather/stanza/pubsub_owner_spec.rb

@@ -3,25 +3,25 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSubOwner do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:pubsub, 'http://jabber.org/protocol/pubsub#owner').should == Blather::Stanza::PubSubOwner
+    expect(Blather::XMPPNode.class_from_registration(:pubsub, 'http://jabber.org/protocol/pubsub#owner')).to eq(Blather::Stanza::PubSubOwner)
   end
 
   it 'ensures a pubusb node is present on create' do
     pubsub = Blather::Stanza::PubSubOwner.new
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_nil
   end
 
   it 'ensures a pubsub node exists when calling #pubsub' do
     pubsub = Blather::Stanza::PubSubOwner.new
     pubsub.remove_children :pubsub
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns).should be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns)).to be_nil
 
-    pubsub.pubsub.should_not be_nil
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns).should_not be_nil
+    expect(pubsub.pubsub).not_to be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSubOwner.registered_ns)).not_to be_nil
   end
 
   it 'sets the host if requested' do
     aff = Blather::Stanza::PubSubOwner.new :get, 'pubsub.jabber.local'
-    aff.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(aff.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 end

data/spec/blather/stanza/pubsub_spec.rb

@@ -3,31 +3,31 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:pubsub, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub
+    expect(Blather::XMPPNode.class_from_registration(:pubsub, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub)
   end
 
   it 'ensures a pubusb node is present on create' do
     pubsub = Blather::Stanza::PubSub.new
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_nil
   end
 
   it 'ensures a pubsub node exists when calling #pubsub' do
     pubsub = Blather::Stanza::PubSub.new
     pubsub.remove_children :pubsub
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns).should be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns)).to be_nil
 
-    pubsub.pubsub.should_not be_nil
-    pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_nil
+    expect(pubsub.pubsub).not_to be_nil
+    expect(pubsub.find_first('/iq/ns:pubsub', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_nil
   end
 
   it 'sets the host if requested' do
     aff = Blather::Stanza::PubSub.new :get, 'pubsub.jabber.local'
-    aff.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(aff.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'ensures newly inherited items are PubSubItem objects' do
     pubsub = Blather::XMPPNode.parse(items_all_nodes_xml)
-    pubsub.items.map { |i| i.class }.uniq.should == [Blather::Stanza::PubSub::PubSubItem]
+    expect(pubsub.items.map { |i| i.class }.uniq).to eq([Blather::Stanza::PubSub::PubSubItem])
   end
 end
 
@@ -35,34 +35,34 @@ describe Blather::Stanza::PubSub::PubSubItem do
   it 'can be initialized with just an ID' do
     id = 'foobarbaz'
     item = Blather::Stanza::PubSub::Items::PubSubItem.new id
-    item.id.should == id
+    expect(item.id).to eq(id)
   end
 
   it 'can be initialized with a payload' do
     payload = 'foobarbaz'
     item = Blather::Stanza::PubSub::Items::PubSubItem.new 'foo', payload
-    item.payload.should == payload
+    expect(item.payload).to eq(payload)
   end
 
   it 'allows the payload to be set' do
     item = Blather::Stanza::PubSub::Items::PubSubItem.new
-    item.payload.should be_nil
+    expect(item.payload).to be_nil
     item.payload = 'testing'
-    item.payload.should == 'testing'
-    item.content.should == 'testing'
+    expect(item.payload).to eq('testing')
+    expect(item.content).to eq('testing')
   end
 
   it 'allows the payload to be unset' do
     payload = 'foobarbaz'
     item = Blather::Stanza::PubSub::Items::PubSubItem.new 'foo', payload
-    item.payload.should == payload
+    expect(item.payload).to eq(payload)
     item.payload = nil
-    item.payload.should be_nil
+    expect(item.payload).to be_nil
   end
 
   it 'makes payloads readable as string' do
     payload = Blather::XMPPNode.new 'foo'
     item = Blather::Stanza::PubSub::Items::PubSubItem.new 'bar', payload
-    item.payload.should == payload.to_s
+    expect(item.payload).to eq(payload.to_s)
   end
 end

data/spec/blather/stanza/x_spec.rb

@@ -32,60 +32,60 @@ describe Blather::Stanza::X do
 
   it 'can be created from an XML string' do
     x = Blather::Stanza::X.new parse_stanza(x_xml).root
-    x.type.should == :form
-    x.should be_instance_of Blather::Stanza::X
+    expect(x.type).to eq(:form)
+    expect(x).to be_instance_of Blather::Stanza::X
   end
 
   [:cancel, :form, :result, :submit].each do |type|
     it "type can be set as \"#{type}\"" do
       x = Blather::Stanza::X.new type
-      x.type.should == type
+      expect(x.type).to eq(type)
     end
   end
 
   it 'is constructed properly' do
     n = Blather::Stanza::X.new :form
-    n.find("/ns:x[@type='form']", :ns => Blather::Stanza::X.registered_ns).should_not be_empty
+    expect(n.find("/ns:x[@type='form']", :ns => Blather::Stanza::X.registered_ns)).not_to be_empty
   end
 
   it 'has an action attribute' do
     n = Blather::Stanza::X.new :form
-    n.type.should == :form
+    expect(n.type).to eq(:form)
     n.type = :submit
-    n.type.should == :submit
+    expect(n.type).to eq(:submit)
   end
 
   it 'has a title attribute' do
     n = Blather::Stanza::X.new :form
-    n.title.should == nil
+    expect(n.title).to eq(nil)
     n.title = "Hello World!"
-    n.title.should == "Hello World!"
+    expect(n.title).to eq("Hello World!")
     n.title = "goodbye"
-    n.title.should == "goodbye"
+    expect(n.title).to eq("goodbye")
   end
 
   it 'has an instructions attribute' do
     n = Blather::Stanza::X.new :form
-    n.instructions.should == nil
+    expect(n.instructions).to eq(nil)
     n.instructions = "Please fill in this form"
-    n.instructions.should == "Please fill in this form"
+    expect(n.instructions).to eq("Please fill in this form")
     n.instructions = "goodbye"
-    n.instructions.should == "goodbye"
+    expect(n.instructions).to eq("goodbye")
   end
 
   it 'inherits a list of fields' do
     n = Blather::Stanza::Iq::Command.new
     n.command << parse_stanza(x_xml).root
     r = Blather::Stanza::X.new.inherit n.form
-    r.fields.size.should == 4
-    r.fields.map { |f| f.class }.uniq.should == [Blather::Stanza::X::Field]
+    expect(r.fields.size).to eq(4)
+    expect(r.fields.map { |f| f.class }.uniq).to eq([Blather::Stanza::X::Field])
   end
 
   it 'returns a field object for a particular var' do
     x = Blather::Stanza::X.new parse_stanza(x_xml).root
     f = x.field 'field-name4'
-    f.should be_instance_of Blather::Stanza::X::Field
-    f.value.should == 'field-value4'
+    expect(f).to be_instance_of Blather::Stanza::X::Field
+    expect(f.value).to eq('field-value4')
   end
 
   it 'takes a list of hashes for fields' do
@@ -98,8 +98,8 @@ describe Blather::Stanza::X do
                 Blather::Stanza::X::Field.new(*%w[var1 text-single label1])]
 
     di = Blather::Stanza::X.new nil, fields
-    di.fields.size.should == 2
-    di.fields.each { |f| control.include?(f).should == true }
+    expect(di.fields.size).to eq(2)
+    di.fields.each { |f| expect(control.include?(f)).to eq(true) }
   end
 
   it 'takes a list of Field objects as fields' do
@@ -107,8 +107,8 @@ describe Blather::Stanza::X do
                 Blather::Stanza::X::Field.new(*%w[var1 text-single label1])]
 
     di = Blather::Stanza::X.new nil, control
-    di.fields.size.should == 2
-    di.fields.each { |f| control.include?(f).should == true }
+    expect(di.fields.size).to eq(2)
+    di.fields.each { |f| expect(control.include?(f)).to eq(true) }
   end
 
   it 'takes a mix of hashes and field objects as fields' do
@@ -121,17 +121,17 @@ describe Blather::Stanza::X do
                 Blather::Stanza::X::Field.new(*%w[var1 text-single label1])]
 
     di = Blather::Stanza::X.new nil, fields
-    di.fields.size.should == 2
-    di.fields.each { |f| control.include?(f).should == true }
+    expect(di.fields.size).to eq(2)
+    di.fields.each { |f| expect(control.include?(f)).to eq(true) }
   end
 
   it 'allows adding of fields' do
     di = Blather::Stanza::X.new nil
-    di.fields.size.should == 0
+    expect(di.fields.size).to eq(0)
     di.fields = [{:label => 'label', :type => 'text-single', :var => 'var', :required => true}]
-    di.fields.size.should == 1
+    expect(di.fields.size).to eq(1)
     di.fields += [Blather::Stanza::X::Field.new(*%w[var1 text-single label1])]
-    di.fields.size.should == 2
+    expect(di.fields.size).to eq(2)
   end
 
 end
@@ -140,76 +140,76 @@ describe Blather::Stanza::X::Field do
   subject { Blather::Stanza::X::Field.new nil }
 
   it "should have the namespace 'jabber:x:data'" do
-    subject.namespace.href.should be == 'jabber:x:data'
+    expect(subject.namespace.href).to eq('jabber:x:data')
   end
 
   it 'will auto-inherit nodes' do
     n = parse_stanza "<field type='text-single' var='music' label='Music from the time of Shakespeare' />"
     i = Blather::Stanza::X::Field.new n.root
-    i.type.should == 'text-single'
-    i.var.should == 'music'
-    i.label.should == 'Music from the time of Shakespeare'
+    expect(i.type).to eq('text-single')
+    expect(i.var).to eq('music')
+    expect(i.label).to eq('Music from the time of Shakespeare')
   end
 
   it 'has a type attribute' do
     n = Blather::Stanza::X::Field.new 'var', 'text-single'
-    n.type.should == 'text-single'
+    expect(n.type).to eq('text-single')
     n.type = 'hidden'
-    n.type.should == 'hidden'
+    expect(n.type).to eq('hidden')
   end
 
   it 'has a var attribute' do
     n = Blather::Stanza::X::Field.new 'name', 'text-single'
-    n.var.should == 'name'
+    expect(n.var).to eq('name')
     n.var = 'email'
-    n.var.should == 'email'
+    expect(n.var).to eq('email')
   end
 
   it 'has a label attribute' do
     n = Blather::Stanza::X::Field.new 'subject', 'text-single', 'Music from the time of Shakespeare'
-    n.label.should == 'Music from the time of Shakespeare'
+    expect(n.label).to eq('Music from the time of Shakespeare')
     n.label = 'Books by and about Shakespeare'
-    n.label.should == 'Books by and about Shakespeare'
+    expect(n.label).to eq('Books by and about Shakespeare')
   end
 
   it 'has a desc attribute' do
     n = Blather::Stanza::X::Field.new 'subject', 'text-single', 'Music from the time of Shakespeare'
-    n.desc.should == nil
+    expect(n.desc).to eq(nil)
     n.desc = 'Books by and about Shakespeare'
-    n.desc.should == 'Books by and about Shakespeare'
+    expect(n.desc).to eq('Books by and about Shakespeare')
     n.desc = 'goodbye'
-    n.desc.should == 'goodbye'
+    expect(n.desc).to eq('goodbye')
   end
 
   it 'has a required? attribute' do
     n = Blather::Stanza::X::Field.new 'subject', 'text-single', 'Music from the time of Shakespeare'
-    n.required?.should == false
+    expect(n.required?).to eq(false)
     n.required = true
-    n.required?.should == true
+    expect(n.required?).to eq(true)
     n.required = false
-    n.required?.should == false
+    expect(n.required?).to eq(false)
   end
 
   it 'has a value attribute' do
     n = Blather::Stanza::X::Field.new 'subject', 'text-single', 'Music from the time of Shakespeare'
-    n.value.should == nil
+    expect(n.value).to eq(nil)
     n.value = 'book1'
-    n.value.should == 'book1'
+    expect(n.value).to eq('book1')
     n.value = 'book2'
-    n.value.should == 'book2'
+    expect(n.value).to eq('book2')
   end
 
   it 'allows setting options' do
     di = Blather::Stanza::X::Field.new nil
-    di.options.size.should == 0
+    expect(di.options.size).to eq(0)
     di.options = [{:label => 'Person', :value => 'person'}, Blather::Stanza::X::Field::Option.new(*%w[person1 Person1])]
-    di.options.size.should == 2
+    expect(di.options.size).to eq(2)
   end
 
   it 'can determine equality' do
     a = Blather::Stanza::X::Field.new('subject', 'text-single')
-    a.should == Blather::Stanza::X::Field.new('subject', 'text-single')
-    a.should_not equal Blather::Stanza::X::Field.new('subject1', 'text-single')
+    expect(a).to eq(Blather::Stanza::X::Field.new('subject', 'text-single'))
+    expect(a).not_to equal Blather::Stanza::X::Field.new('subject1', 'text-single')
   end
 end
 
@@ -217,17 +217,17 @@ describe Blather::Stanza::X::Field::Option do
 
   it 'has a value attribute' do
     n = Blather::Stanza::X::Field::Option.new 'person1', 'Person 1'
-    n.value.should == 'person1'
+    expect(n.value).to eq('person1')
     n.value = 'book1'
-    n.value.should == 'book1'
+    expect(n.value).to eq('book1')
   end
 
   it 'has a label attribute' do
     n = Blather::Stanza::X::Field::Option.new 'person1', 'Person 1'
-    n.label.should == 'Person 1'
+    expect(n.label).to eq('Person 1')
     n.label = 'Book 1'
-    n.label.should == 'Book 1'
+    expect(n.label).to eq('Book 1')
     n.label = 'Book 2'
-    n.label.should == 'Book 2'
+    expect(n.label).to eq('Book 2')
   end
 end