blather 1.2.0 → 2.0.0

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

@@ -3,81 +3,81 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Publish do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:publish, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Publish
+    expect(Blather::XMPPNode.class_from_registration(:publish, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub::Publish)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(publish_xml).should be_instance_of Blather::Stanza::PubSub::Publish
+    expect(Blather::XMPPNode.parse(publish_xml)).to be_instance_of Blather::Stanza::PubSub::Publish
   end
 
   it 'ensures an publish node is present on create' do
     publish = Blather::Stanza::PubSub::Publish.new
-    publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures an publish node exists when calling #publish' do
     publish = Blather::Stanza::PubSub::Publish.new
     publish.pubsub.remove_children :publish
-    publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
-    publish.publish.should_not be_nil
-    publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.publish).not_to be_nil
+    expect(publish.find('//ns:pubsub/ns:publish', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     publish = Blather::Stanza::PubSub::Publish.new
-    publish.type.should == :set
+    expect(publish.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     publish = Blather::Stanza::PubSub::Publish.new 'pubsub.jabber.local'
-    publish.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(publish.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     publish = Blather::Stanza::PubSub::Publish.new 'host', 'node-name'
-    publish.node.should == 'node-name'
+    expect(publish.node).to eq('node-name')
   end
 
   it 'will iterate over each item' do
     publish = Blather::Stanza::PubSub::Publish.new.inherit parse_stanza(publish_xml).root
     count = 0
     publish.each do |i|
-      i.should be_instance_of Blather::Stanza::PubSub::PubSubItem
+      expect(i).to be_instance_of Blather::Stanza::PubSub::PubSubItem
       count += 1
     end
-    count.should == 1
+    expect(count).to eq(1)
   end
 
   it 'has a node attribute' do
     publish = Blather::Stanza::PubSub::Publish.new
-    publish.should respond_to :node
-    publish.node.should be_nil
+    expect(publish).to respond_to :node
+    expect(publish.node).to be_nil
     publish.node = 'node-name'
-    publish.node.should == 'node-name'
-    publish.xpath('//ns:publish[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.node).to eq('node-name')
+    expect(publish.xpath('//ns:publish[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'can set the payload with a hash' do
     payload = {'id1' => 'payload1', 'id2' => 'payload2'}
     publish = Blather::Stanza::PubSub::Publish.new
     publish.payload = payload
-    publish.size.should == 2
-    publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[@id="id1" and .="payload1"] and ns:item[@id="id2" and .="payload2"]]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.size).to eq(2)
+    expect(publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[@id="id1" and .="payload1"] and ns:item[@id="id2" and .="payload2"]]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'can set the payload with an array' do
     payload = %w[payload1 payload2]
     publish = Blather::Stanza::PubSub::Publish.new
     publish.payload = payload
-    publish.size.should == 2
-    publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[.="payload1"] and ns:item[.="payload2"]]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.size).to eq(2)
+    expect(publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[.="payload1"] and ns:item[.="payload2"]]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'can set the payload with a string' do
     publish = Blather::Stanza::PubSub::Publish.new
     publish.payload = 'payload'
-    publish.size.should == 1
-    publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[.="payload"]]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(publish.size).to eq(1)
+    expect(publish.xpath('/iq/ns:pubsub/ns:publish[ns:item[.="payload"]]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 end

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

@@ -3,73 +3,73 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Retract do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:retract, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Retract
+    expect(Blather::XMPPNode.class_from_registration(:retract, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub::Retract)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(retract_xml).should be_instance_of Blather::Stanza::PubSub::Retract
+    expect(Blather::XMPPNode.parse(retract_xml)).to be_instance_of Blather::Stanza::PubSub::Retract
   end
 
   it 'ensures an retract node is present on create' do
     retract = Blather::Stanza::PubSub::Retract.new
-    retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures an retract node exists when calling #retract' do
     retract = Blather::Stanza::PubSub::Retract.new
     retract.pubsub.remove_children :retract
-    retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
-    retract.retract.should_not be_nil
-    retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(retract.retract).not_to be_nil
+    expect(retract.find('//ns:pubsub/ns:retract', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     retract = Blather::Stanza::PubSub::Retract.new
-    retract.type.should == :set
+    expect(retract.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     retract = Blather::Stanza::PubSub::Retract.new 'pubsub.jabber.local'
-    retract.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(retract.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     retract = Blather::Stanza::PubSub::Retract.new 'host', 'node-name'
-    retract.node.should == 'node-name'
+    expect(retract.node).to eq('node-name')
   end
 
   it 'can set the retractions as a string' do
     retract = Blather::Stanza::PubSub::Retract.new 'host', 'node'
     retract.retractions = 'id1'
-    retract.xpath('//ns:retract[ns:item[@id="id1"]]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(retract.xpath('//ns:retract[ns:item[@id="id1"]]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'can set the retractions as an array' do
     retract = Blather::Stanza::PubSub::Retract.new 'host', 'node'
     retract.retractions = %w[id1 id2]
-    retract.xpath('//ns:retract[ns:item[@id="id1"] and ns:item[@id="id2"]]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(retract.xpath('//ns:retract[ns:item[@id="id1"] and ns:item[@id="id2"]]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'will iterate over each item' do
     retract = Blather::Stanza::PubSub::Retract.new.inherit parse_stanza(retract_xml).root
-    retract.retractions.size.should == 1
-    retract.size.should == retract.retractions.size
-    retract.retractions.should == %w[ae890ac52d0df67ed7cfdf51b644e901]
+    expect(retract.retractions.size).to eq(1)
+    expect(retract.size).to eq(retract.retractions.size)
+    expect(retract.retractions).to eq(%w[ae890ac52d0df67ed7cfdf51b644e901])
   end
 
   it 'has a node attribute' do
     retract = Blather::Stanza::PubSub::Retract.new
-    retract.should respond_to :node
-    retract.node.should be_nil
+    expect(retract).to respond_to :node
+    expect(retract.node).to be_nil
     retract.node = 'node-name'
-    retract.node.should == 'node-name'
-    retract.xpath('//ns:retract[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(retract.node).to eq('node-name')
+    expect(retract.xpath('//ns:retract[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'will iterate over each retraction' do
     Blather::XMPPNode.parse(retract_xml).each do |i|
-      i.should include "ae890ac52d0df67ed7cfdf51b644e901"
+      expect(i).to include "ae890ac52d0df67ed7cfdf51b644e901"
     end
   end
 end

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

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

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

@@ -3,94 +3,94 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Subscription do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:subscription, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Subscription
+    expect(Blather::XMPPNode.class_from_registration(:subscription, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub::Subscription)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(subscription_xml).should be_instance_of Blather::Stanza::PubSub::Subscription
+    expect(Blather::XMPPNode.parse(subscription_xml)).to be_instance_of Blather::Stanza::PubSub::Subscription
   end
 
   it 'ensures an subscription node is present on create' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node', 'jid', 'subid', :none
-    subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures an subscription node exists when calling #subscription_node' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node', 'jid', 'subid', :none
     subscription.pubsub.remove_children :subscription
-    subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
-    subscription.subscription_node.should_not be_nil
-    subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(subscription.subscription_node).not_to be_nil
+    expect(subscription.find('//ns:pubsub/ns:subscription', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'defaults to a set node' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node', 'jid', 'subid', :none
-    subscription.type.should == :set
+    expect(subscription.type).to eq(:set)
   end
 
   it 'sets the host if requested' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'pubsub.jabber.local', 'node', 'jid', 'subid', :none
-    subscription.to.should == Blather::JID.new('pubsub.jabber.local')
+    expect(subscription.to).to eq(Blather::JID.new('pubsub.jabber.local'))
   end
 
   it 'sets the node' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :none
-    subscription.node.should == 'node-name'
+    expect(subscription.node).to eq('node-name')
   end
 
   it 'has a node attribute' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :none
-    subscription.find('//ns:pubsub/ns:subscription[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.node.should == 'node-name'
+    expect(subscription.find('//ns:pubsub/ns:subscription[@node="node-name"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.node).to eq('node-name')
 
     subscription.node = 'new-node'
-    subscription.find('//ns:pubsub/ns:subscription[@node="new-node"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.node.should == 'new-node'
+    expect(subscription.find('//ns:pubsub/ns:subscription[@node="new-node"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.node).to eq('new-node')
   end
 
   it 'has a jid attribute' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :none
-    subscription.find('//ns:pubsub/ns:subscription[@jid="jid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.jid.should == Blather::JID.new('jid')
+    expect(subscription.find('//ns:pubsub/ns:subscription[@jid="jid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.jid).to eq(Blather::JID.new('jid'))
 
     subscription.jid = Blather::JID.new('n@d/r')
-    subscription.find('//ns:pubsub/ns:subscription[@jid="n@d/r"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.jid.should == Blather::JID.new('n@d/r')
+    expect(subscription.find('//ns:pubsub/ns:subscription[@jid="n@d/r"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.jid).to eq(Blather::JID.new('n@d/r'))
   end
 
   it 'has a subid attribute' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :none
-    subscription.find('//ns:pubsub/ns:subscription[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.subid.should == 'subid'
+    expect(subscription.find('//ns:pubsub/ns:subscription[@subid="subid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.subid).to eq('subid')
 
     subscription.subid = 'new-subid'
-    subscription.find('//ns:pubsub/ns:subscription[@subid="new-subid"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.subid.should == 'new-subid'
+    expect(subscription.find('//ns:pubsub/ns:subscription[@subid="new-subid"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.subid).to eq('new-subid')
   end
 
   it 'has a subscription attribute' do
     subscription = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :none
-    subscription.find('//ns:pubsub/ns:subscription[@subscription="none"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.subscription.should == :none
+    expect(subscription.find('//ns:pubsub/ns:subscription[@subscription="none"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.subscription).to eq(:none)
 
     subscription.subscription = :pending
-    subscription.find('//ns:pubsub/ns:subscription[@subscription="pending"]', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
-    subscription.subscription.should == :pending
+    expect(subscription.find('//ns:pubsub/ns:subscription[@subscription="pending"]', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
+    expect(subscription.subscription).to eq(:pending)
   end
 
   it 'ensures subscription is one of Stanza::PubSub::Subscription::VALID_TYPES' do
-    lambda { Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :invalid_type_name }.should raise_error(Blather::ArgumentError)
+    expect { Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', :invalid_type_name }.to raise_error(Blather::ArgumentError)
 
     Blather::Stanza::PubSub::Subscription::VALID_TYPES.each do |valid_type|
       n = Blather::Stanza::PubSub::Subscription.new :set, 'host', 'node-name', 'jid', 'subid', valid_type
-      n.subscription.should == valid_type
+      expect(n.subscription).to eq(valid_type)
     end
   end
 
   Blather::Stanza::PubSub::Subscription::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Blather::Stanza::PubSub::Subscription.new.should respond_to :"#{valid_type}?"
+      expect(Blather::Stanza::PubSub::Subscription.new).to respond_to :"#{valid_type}?"
     end
   end
 

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

@@ -10,59 +10,59 @@ end
 
 describe Blather::Stanza::PubSub::Subscriptions do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:subscriptions, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Subscriptions
+    expect(Blather::XMPPNode.class_from_registration(:subscriptions, 'http://jabber.org/protocol/pubsub')).to eq(Blather::Stanza::PubSub::Subscriptions)
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.parse(subscriptions_xml).should be_instance_of Blather::Stanza::PubSub::Subscriptions
+    expect(Blather::XMPPNode.parse(subscriptions_xml)).to be_instance_of Blather::Stanza::PubSub::Subscriptions
   end
 
   it 'ensures an subscriptions node is present on create' do
     subscriptions = Blather::Stanza::PubSub::Subscriptions.new
-    subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures an subscriptions node exists when calling #subscriptions' do
     subscriptions = Blather::Stanza::PubSub::Subscriptions.new
     subscriptions.pubsub.remove_children :subscriptions
-    subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
-    subscriptions.subscriptions.should_not be_nil
-    subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
+    expect(subscriptions.subscriptions).not_to be_nil
+    expect(subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns)).not_to be_empty
   end
 
   it 'ensures the subscriptions node is not duplicated when calling #subscriptions' do
     subscriptions = Blather::Stanza::PubSub::Subscriptions.new
     subscriptions.pubsub.remove_children :subscriptions
-    subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
+    expect(subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns)).to be_empty
 
     5.times { subscriptions.subscriptions }
-    subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).count.should eq(1)
+    expect(subscriptions.find('//ns:pubsub/ns:subscriptions', :ns => Blather::Stanza::PubSub.registered_ns).count).to eq(1)
   end
 
   it 'defaults to a get node' do
     aff = Blather::Stanza::PubSub::Subscriptions.new
-    aff.type.should == :get
+    expect(aff.type).to eq(:get)
   end
 
   it 'sets the host if requested' do
     aff = Blather::Stanza::PubSub::Subscriptions.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 'can import a subscriptions result node' do
     node = parse_stanza(subscriptions_xml).root
 
     subscriptions = Blather::Stanza::PubSub::Subscriptions.new.inherit node
-    subscriptions.size.should == 4
-    subscriptions.list.should == control_subscriptions
+    expect(subscriptions.size).to eq(4)
+    expect(subscriptions.list).to eq(control_subscriptions)
   end
 
   it 'will iterate over each subscription' do
     node = parse_stanza(subscriptions_xml).root
     subscriptions = Blather::Stanza::PubSub::Subscriptions.new.inherit node
     subscriptions.each do |type, nodes|
-      nodes.should == control_subscriptions[type]
+      expect(nodes).to eq(control_subscriptions[type])
     end
   end
 end