punchblock 2.5.2 → 2.5.3

data/spec/punchblock/component/send_fax_spec.rb

@@ -6,19 +6,22 @@ module Punchblock
   module Component
     describe SendFax do
       it 'registers itself' do
-        RayoNode.class_from_registration(:sendfax, 'urn:xmpp:rayo:fax:1').should be == described_class
+        expect(RayoNode.class_from_registration(:sendfax, 'urn:xmpp:rayo:fax:1')).to eq(described_class)
       end
 
       subject do
         SendFax.new render_documents: [SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff', pages: [1..4,5,7..9])]
       end
 
-      its(:render_documents) { should be == [SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff', pages: [1..4,5,7..9])] }
+      describe '#render_documents' do
+        subject { super().render_documents }
+        it { should be == [SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff', pages: [1..4,5,7..9])] }
+      end
 
       describe "exporting to Rayo" do
         it "should export to XML that can be understood by its parser" do
           new_instance = RayoNode.from_xml Nokogiri::XML(subject.to_rayo.to_xml, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).root
-          new_instance.render_documents.should be == [SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff', pages: [1..4,5,7..9])]
+          expect(new_instance.render_documents).to eq([SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff', pages: [1..4,5,7..9])])
         end
       end
 
@@ -30,7 +33,7 @@ module Punchblock
         describe "exporting to Rayo" do
           it "should export to XML that can be understood by its parser" do
             new_instance = RayoNode.from_xml Nokogiri::XML(subject.to_rayo.to_xml, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).root
-            new_instance.render_documents.should be == [SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff')]
+            expect(new_instance.render_documents).to eq([SendFax::FaxDocument.new(url: 'http://example.com/faxes/document.tiff')])
           end
         end
       end
@@ -47,7 +50,10 @@ module Punchblock
             MESSAGE
         end
 
-        its(:render_documents) { should be == [SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff', identity: '+14045555555', header: 'Hello world', pages: [1..4,5,7..9])] }
+        describe '#render_documents' do
+          subject { super().render_documents }
+          it { should be == [SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff', identity: '+14045555555', header: 'Hello world', pages: [1..4,5,7..9])] }
+        end
 
         context "without optional attributes" do
           let :stanza do
@@ -58,30 +64,63 @@ module Punchblock
               MESSAGE
           end
 
-          its(:render_documents) { should be == [SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff')] }
+          describe '#render_documents' do
+            subject { super().render_documents }
+            it { should be == [SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff')] }
+          end
         end
       end
     end
 
     describe SendFax::FaxDocument do
       it "registers itself" do
-        RayoNode.class_from_registration(:document, 'urn:xmpp:rayo:fax:1').should be == described_class
+        expect(RayoNode.class_from_registration(:document, 'urn:xmpp:rayo:fax:1')).to eq(described_class)
       end
 
       subject { SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff', identity: '+14045555555', header: 'Hello world', pages: [1..4,5,7..9]) }
 
-      its(:url)       { should == 'http://shakespere.lit/my_fax.tiff' }
-      its(:identity)  { should == '+14045555555' }
-      its(:header)    { should == 'Hello world' }
-      its(:pages)     { should == [1..4,5,7..9] }
+      describe '#url' do
+        subject { super().url }
+        it { should == 'http://shakespere.lit/my_fax.tiff' }
+      end
+
+      describe '#identity' do
+        subject { super().identity }
+        it { should == '+14045555555' }
+      end
+
+      describe '#header' do
+        subject { super().header }
+        it { should == 'Hello world' }
+      end
+
+      describe '#pages' do
+        subject { super().pages }
+        it { should == [1..4,5,7..9] }
+      end
 
       context "without optional attributes" do
         subject { SendFax::FaxDocument.new(url: 'http://shakespere.lit/my_fax.tiff') }
 
-        its(:url)       { should == 'http://shakespere.lit/my_fax.tiff' }
-        its(:identity)  { should be_nil }
-        its(:header)    { should be_nil }
-        its(:pages)     { should be_nil }
+        describe '#url' do
+          subject { super().url }
+          it { should == 'http://shakespere.lit/my_fax.tiff' }
+        end
+
+        describe '#identity' do
+          subject { super().identity }
+          it { should be_nil }
+        end
+
+        describe '#header' do
+          subject { super().header }
+          it { should be_nil }
+        end
+
+        describe '#pages' do
+          subject { super().pages }
+          it { should be_nil }
+        end
       end
 
       describe "comparison" do

data/spec/punchblock/connection/asterisk_spec.rb

@@ -16,59 +16,69 @@ module Punchblock
 
       let(:mock_event_handler) { double('Event Handler').as_null_object }
 
-      let(:connection) { Asterisk.new options }
-
-      subject { connection }
+      subject(:connection) { Asterisk.new options }
 
       before do
-        subject.event_handler = mock_event_handler
+        connection.event_handler = mock_event_handler
+      end
+
+      describe '#ami_client' do
+        subject { connection.ami_client }
+
+        it { should be_a RubyAMIStreamProxy }
       end
 
-      its(:ami_client) { should be_a RubyAMIStreamProxy }
-      its('ami_client.stream') { should be_a RubyAMI::Stream }
+      describe '#ami_client' do
+        describe '#stream' do
+          subject { connection.ami_client.stream }
+
+          it { should be_a RubyAMI::Stream }
+        end
+      end
 
       it 'should set the connection on the translator' do
-        subject.translator.connection.should be subject
+        expect(subject.translator.connection).to be subject
       end
 
       describe '#run' do
         it 'starts the RubyAMI::Stream' do
-          subject.ami_client.async.should_receive(:run).once do
+          expect(subject.ami_client.async).to receive(:run).once do
             subject.ami_client.terminate
           end
-          lambda { subject.run }.should raise_error DisconnectedError
+          expect { subject.run }.to raise_error DisconnectedError
         end
 
         it 'rebuilds the RubyAMI::Stream if dead' do
-          subject.ami_client.async.should_receive(:run).once do
+          pending
+          expect(subject.ami_client.async).to receive(:run).once do
             subject.ami_client.terminate
           end
-          lambda { subject.run }.should raise_error DisconnectedError
-          subject.ami_client.alive?.should be_false
-          subject.should_receive(:new_ami_stream).once do
-            subject.ami_client.alive?.should be_true
-            subject.ami_client.async.should_receive(:run).once
+          expect { subject.run }.to raise_error DisconnectedError
+          expect(subject.ami_client.alive?).to be_false
+          expect(subject).to receive(:new_ami_stream).once.and_return do
+            expect(subject.ami_client.alive?).to be true
+            expect(subject.ami_client.async).to receive(:run).once
           end
-          lambda { subject.run }.should_not raise_error DisconnectedError
+          expect { subject.run }.not_to raise_error
         end
       end
 
       describe '#stop' do
         it 'stops the RubyAMI::Stream' do
-          subject.ami_client.should_receive(:terminate).once
+          expect(subject.ami_client).to receive(:terminate).once
           subject.stop
         end
 
         it 'shuts down the translator' do
-          subject.translator.should_receive(:terminate).once
+          expect(subject.translator).to receive(:terminate).once
           subject.stop
         end
       end
 
       it 'sends events from RubyAMI to the translator' do
         event = RubyAMI::Event.new 'FullyBooted'
-        subject.translator.async.should_receive(:handle_ami_event).once.with event
-        subject.translator.async.should_receive(:handle_ami_event).once.with RubyAMI::Stream::Disconnected.new
+        expect(subject.translator.async).to receive(:handle_ami_event).once.with event
+        expect(subject.translator.async).to receive(:handle_ami_event).once.with RubyAMI::Stream::Disconnected.new
         subject.ami_client.message_received event
       end
 
@@ -76,7 +86,7 @@ module Punchblock
         it 'sends a command to the translator' do
           command = double 'Command'
           options = {:foo => :bar}
-          subject.translator.async.should_receive(:execute_command).once.with command, options
+          expect(subject.translator.async).to receive(:execute_command).once.with command, options
           subject.write command, options
         end
       end
@@ -86,7 +96,7 @@ module Punchblock
           offer = Event::Offer.new
           offer.target_call_id = '9f00061'
 
-          mock_event_handler.should_receive(:call).once.with offer
+          expect(mock_event_handler).to receive(:call).once.with offer
           subject.handle_event offer
         end
       end
@@ -94,13 +104,13 @@ module Punchblock
       describe '#new_call_uri' do
         it "should return a random UUID" do
           stub_uuids 'foobar'
-          subject.new_call_uri.should == 'foobar'
+          expect(subject.new_call_uri).to eq('foobar')
         end
       end
 
       describe '#send_message' do
         it 'passes the message to the translator for dispatch' do
-          subject.translator.should_receive(:send_message).once.with(:foo)
+          expect(subject.translator).to receive(:send_message).once.with(:foo)
           subject.send_message :foo
         end
       end

data/spec/punchblock/connection/freeswitch_spec.rb

@@ -26,33 +26,33 @@ module Punchblock
       end
 
       it 'should set the connection on the translator' do
-        subject.translator.connection.should be subject
+        expect(subject.translator.connection).to be subject
       end
 
       describe '#run' do
         it 'starts a RubyFS stream' do
           # subject.should_receive(:new_fs_stream).once.with('127.0.0.1', 8021, 'test').and_return mock_stream
-          subject.stream.should_receive(:run).once
-          lambda { subject.run }.should raise_error(DisconnectedError)
+          expect(subject.stream).to receive(:run).once
+          expect { subject.run }.to raise_error(DisconnectedError)
         end
       end
 
       describe '#stop' do
         it 'stops the RubyFS::Stream' do
-          subject.stream.should_receive(:shutdown).once
+          expect(subject.stream).to receive(:shutdown).once
           subject.stop
         end
 
         it 'shuts down the translator' do
-          subject.translator.should_receive(:terminate).once
+          expect(subject.translator).to receive(:terminate).once
           subject.stop
         end
       end
 
       it 'sends events from RubyFS to the translator' do
         event = double 'RubyFS::Event'
-        subject.translator.async.should_receive(:handle_es_event).once.with event
-        subject.translator.async.should_receive(:handle_es_event).once.with RubyFS::Stream::Disconnected.new
+        expect(subject.translator.async).to receive(:handle_es_event).once.with event
+        expect(subject.translator.async).to receive(:handle_es_event).once.with RubyFS::Stream::Disconnected.new
         subject.stream.fire_event event
       end
 
@@ -60,7 +60,7 @@ module Punchblock
         it 'sends a command to the translator' do
           command = double 'Command'
           options = {:foo => :bar}
-          subject.translator.async.should_receive(:execute_command).once.with command, options
+          expect(subject.translator.async).to receive(:execute_command).once.with command, options
           subject.write command, options
         end
       end
@@ -70,7 +70,7 @@ module Punchblock
           offer = Event::Offer.new
           offer.target_call_id = '9f00061'
 
-          mock_event_handler.should_receive(:call).once.with offer
+          expect(mock_event_handler).to receive(:call).once.with offer
           subject.handle_event offer
         end
       end

data/spec/punchblock/connection/xmpp_spec.rb

@@ -22,11 +22,14 @@ module Punchblock
         context "with no domains specified, and a JID of 1@app.rayo.net" do
           let(:options) { { :username => '1@app.rayo.net' } }
 
-          its(:root_domain)   { should be == 'app.rayo.net' }
+          describe '#root_domain' do
+            subject { super().root_domain }
+            it { should be == 'app.rayo.net' }
+          end
 
           describe '#new_call_uri' do
             it "should return an appropriate random call URI" do
-              subject.new_call_uri.should == 'xmpp:randomcallid@app.rayo.net'
+              expect(subject.new_call_uri).to eq('xmpp:randomcallid@app.rayo.net')
             end
           end
         end
@@ -34,11 +37,14 @@ module Punchblock
         context "with only a rayo domain set" do
           let(:options) { { :rayo_domain => 'rayo.org' } }
 
-          its(:root_domain)   { should be == 'rayo.org' }
+          describe '#root_domain' do
+            subject { super().root_domain }
+            it { should be == 'rayo.org' }
+          end
 
           describe '#new_call_uri' do
             it "should return an appropriate random call URI" do
-              subject.new_call_uri.should == 'xmpp:randomcallid@rayo.org'
+              expect(subject.new_call_uri).to eq('xmpp:randomcallid@rayo.org')
             end
           end
         end
@@ -46,11 +52,14 @@ module Punchblock
         context "with only a root domain set" do
           let(:options) { { :root_domain => 'rayo.org' } }
 
-          its(:root_domain)   { should be == 'rayo.org' }
+          describe '#root_domain' do
+            subject { super().root_domain }
+            it { should be == 'rayo.org' }
+          end
 
           describe '#new_call_uri' do
             it "should return an appropriate random call URI" do
-              subject.new_call_uri.should == 'xmpp:randomcallid@rayo.org'
+              expect(subject.new_call_uri).to eq('xmpp:randomcallid@rayo.org')
             end
           end
         end
@@ -65,7 +74,7 @@ module Punchblock
         old_logger = Punchblock.logger
         Punchblock.logger = :foo
         XMPP.new :username => '1@call.rayo.net', :password => 1
-        Blather.logger.should be :foo
+        expect(Blather.logger).to be :foo
         Punchblock.logger = old_logger
       end
 
@@ -86,9 +95,9 @@ module Punchblock
 </output>
         MSG
         output = RayoNode.import parse_stanza(output).root
-        connection.should_receive(:write_to_stream).once.and_return true
+        expect(connection).to receive(:write_to_stream).once.and_return true
         iq = Blather::Stanza::Iq.new :set, '9f00061@call.rayo.net'
-        connection.should_receive(:create_iq).and_return iq
+        expect(connection).to receive(:create_iq).and_return iq
 
         write_thread = Thread.new do
           connection.write offer.call_id, output
@@ -106,9 +115,9 @@ module Punchblock
 
         write_thread.join
 
-        output.state_name.should be == :executing
+        expect(output.state_name).to eq(:executing)
 
-        connection.original_component_from_id('fgh4590').should be == output
+        expect(connection.original_component_from_id('fgh4590')).to eq(output)
 
         example_complete = import_stanza <<-MSG
 <presence to='16577@app.rayo.net/1' from='9f00061@call.rayo.net/fgh4590'>
@@ -119,80 +128,80 @@ module Punchblock
         MSG
 
         connection.__send__ :handle_presence, example_complete
-        output.complete_event(0.5).source.should be == output
+        expect(output.complete_event(0.5).source).to eq(output)
 
-        output.component_id.should be == 'fgh4590'
+        expect(output.component_id).to eq('fgh4590')
       end
 
       let(:client) { connection.send :client }
-      before { client.stub :write }
+      before { allow(client).to receive :write }
 
       describe "sending a command" do
         let(:command) { Punchblock::Command::Answer.new request_id: 'fooobarrr', target_call_id: 'foo', domain: 'bar.com' }
 
         it "should write an IQ containing the command to the socket" do
-          client.should_receive(:write).once.with do |stanza|
-            stanza.should be_a Blather::Stanza::Iq
-            stanza.to.should be == 'foo@bar.com'
-            stanza.type.should be == :set
-          end
+          expect(client).to receive(:write).once.with { |stanza|
+            expect(stanza).to be_a Blather::Stanza::Iq
+            expect(stanza.to).to eq('foo@bar.com')
+            expect(stanza.type).to eq(:set)
+          }
           connection.write command
         end
 
         it "should put the command in a requested state" do
           connection.write command
-          command.should be_requested
+          expect(command).to be_requested
         end
 
         it "should use the command's request_id as the ID id" do
-          client.should_receive(:write).once.with do |stanza|
-            stanza.id.should be == 'fooobarrr'
-          end
+          expect(client).to receive(:write).once.with { |stanza|
+            expect(stanza.id).to eq('fooobarrr')
+          }
           connection.write command
         end
       end
 
       it 'should send a "Chat" presence when ready' do
-        client.should_receive(:write).once.with do |stanza|
-          stanza.to.should be == 'rayo.net'
-          stanza.should be_a Blather::Stanza::Presence::Status
-          stanza.chat?.should be true
-        end
+        expect(client).to receive(:write).once.with { |stanza|
+          expect(stanza.to).to eq('rayo.net')
+          expect(stanza).to be_a Blather::Stanza::Presence::Status
+          expect(stanza.chat?).to be true
+        }
         connection.ready!
       end
 
       it 'should send a "Do Not Disturb" presence when not_ready' do
-        client.should_receive(:write).once.with do |stanza|
-          stanza.to.should be == 'rayo.net'
-          stanza.should be_a Blather::Stanza::Presence::Status
-          stanza.dnd?.should be true
-        end
+        expect(client).to receive(:write).once.with { |stanza|
+          expect(stanza.to).to eq('rayo.net')
+          expect(stanza).to be_a Blather::Stanza::Presence::Status
+          expect(stanza.dnd?).to be true
+        }
         connection.not_ready!
       end
 
       describe '#send_message' do
         it 'should send a "normal" message to the given user and domain' do
-          client.should_receive(:write).once.with do |stanza|
-            stanza.to.should be == 'someone@example.org'
-            stanza.should be_a Blather::Stanza::Message
-            stanza.type.should == :normal
-            stanza.body.should be == 'Hello World!'
-            stanza.subject.should be_nil
-          end
+          expect(client).to receive(:write).once.with { |stanza|
+            expect(stanza.to).to eq('someone@example.org')
+            expect(stanza).to be_a Blather::Stanza::Message
+            expect(stanza.type).to eq(:normal)
+            expect(stanza.body).to eq('Hello World!')
+            expect(stanza.subject).to be_nil
+          }
           connection.send_message 'someone', 'example.org', 'Hello World!'
         end
 
         it 'should default to the root domain' do
-          client.should_receive(:write).once.with do |stanza|
-            stanza.to.should be == 'someone@rayo.net'
-          end
+          expect(client).to receive(:write).once.with { |stanza|
+            expect(stanza.to).to eq('someone@rayo.net')
+          }
           connection.send_message "someone", nil, nil
         end
 
         it 'should send a message with the given subject' do
-          client.should_receive(:write).once.with do |stanza|
-            stanza.subject.should be == "Important Message"
-          end
+          expect(client).to receive(:write).once.with { |stanza|
+            expect(stanza.subject).to eq("Important Message")
+          }
           connection.send_message nil, nil, nil, :subject => "Important Message"
         end
       end
@@ -210,15 +219,15 @@ module Punchblock
 
         let(:example_complete) { import_stanza complete_xml }
 
-        it { example_complete.should be_a Blather::Stanza::Presence }
+        it { expect(example_complete).to be_a Blather::Stanza::Presence }
 
         describe "accessing the rayo node for a presence stanza" do
           it "should import the rayo node" do
-            example_complete.rayo_node.should be_a Punchblock::Event::Complete
+            expect(example_complete.rayo_node).to be_a Punchblock::Event::Complete
           end
 
           it "should be memoized" do
-            example_complete.rayo_node.should be example_complete.rayo_node
+            expect(example_complete.rayo_node).to be example_complete.rayo_node
           end
         end
 
@@ -244,17 +253,17 @@ module Punchblock
 
             let(:example_event) { import_stanza offer_xml }
 
-            it { example_event.should be_a Blather::Stanza::Presence }
+            it { expect(example_event).to be_a Blather::Stanza::Presence }
 
             it 'should call the event handler with the event' do
-              mock_event_handler.should_receive(:call).once.with do |event|
-                event.should be_instance_of Event::Offer
-                event.target_call_id.should be == '9f00061'
-                event.source_uri.should be == 'xmpp:9f00061@call.rayo.net'
-                event.domain.should be == 'call.rayo.net'
-                event.transport.should be == 'xmpp'
-                event.timestamp.should be == @now
-              end
+              expect(mock_event_handler).to receive(:call).once.with { |event|
+                expect(event).to be_instance_of Event::Offer
+                expect(event.target_call_id).to eq('9f00061')
+                expect(event.source_uri).to eq('xmpp:9f00061@call.rayo.net')
+                expect(event.domain).to eq('call.rayo.net')
+                expect(event.transport).to eq('xmpp')
+                expect(event.timestamp).to eq(@now)
+              }
               handle_presence
             end
 
@@ -269,9 +278,9 @@ module Punchblock
               end
 
               it 'should stamp that time on the rayo event' do
-                mock_event_handler.should_receive(:call).once.with do |event|
-                  event.timestamp.should be == DateTime.new(2002, 9, 10, 23, 8, 25, 0)
-                end
+                expect(mock_event_handler).to receive(:call).once.with { |event|
+                  expect(event.timestamp).to eq(DateTime.new(2002, 9, 10, 23, 8, 25, 0))
+                }
                 handle_presence
               end
             end
@@ -289,16 +298,16 @@ module Punchblock
             let(:example_event) { import_stanza irrelevant_xml }
 
             it 'should not be considered to be a rayo event' do
-              example_event.rayo_event?.should be_false
+              expect(example_event.rayo_event?).to be_false
             end
 
             it 'should have a nil rayo_node' do
-              example_event.rayo_node.should be_nil
+              expect(example_event.rayo_node).to be_nil
             end
 
             it 'should not handle the event' do
-              mock_event_handler.should_receive(:call).never
-              lambda { handle_presence }.should throw_symbol(:pass)
+              expect(mock_event_handler).to receive(:call).never
+              expect { handle_presence }.to throw_symbol(:pass)
             end
           end
         end
@@ -330,19 +339,19 @@ module Punchblock
         subject { cmd.response }
 
         it "should have the correct call ID" do
-          subject.call_id.should be == call_id
+          expect(subject.call_id).to eq(call_id)
         end
 
         it "should have the correct component ID" do
-          subject.component_id.should be == component_id
+          expect(subject.component_id).to eq(component_id)
         end
 
         it "should have the correct name" do
-          subject.name.should be == :item_not_found
+          expect(subject.name).to eq(:item_not_found)
         end
 
         it "should have the correct text" do
-          subject.text.should be == 'Could not find call [id=f6d437f4-1e18-457b-99f8-b5d853f50347]'
+          expect(subject.text).to eq('Could not find call [id=f6d437f4-1e18-457b-99f8-b5d853f50347]')
         end
       end
 
@@ -355,7 +364,7 @@ module Punchblock
 
           it "should use the correct JID" do
             stanza = subject.prep_command_for_execution command
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
         end
 
@@ -364,7 +373,7 @@ module Punchblock
           let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
 
           context "with a domain specified" do
@@ -372,7 +381,7 @@ module Punchblock
 
             it "should use the specified domain in the JID" do
               stanza = subject.prep_command_for_execution command, domain: 'calls.rayo.net'
-              stanza.to.should be == expected_jid
+              expect(stanza.to).to eq(expected_jid)
             end
           end
         end
@@ -382,7 +391,7 @@ module Punchblock
           let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
         end
 
@@ -391,7 +400,7 @@ module Punchblock
           let(:expected_jid)  { 'abc123@rayo.net/foobar' }
 
           it "should use the correct JID" do
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
         end
 
@@ -400,7 +409,7 @@ module Punchblock
           let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
         end
 
@@ -409,7 +418,7 @@ module Punchblock
           let(:expected_jid)  { 'abc123@rayo.net/foobar' }
 
           it "should use the correct JID" do
-            stanza.to.should be == expected_jid
+            expect(stanza.to).to eq(expected_jid)
           end
         end
       end
@@ -417,7 +426,7 @@ module Punchblock
       describe "receiving events from a mixer" do
         context "after joining the mixer" do
           before do
-            client.should_receive :write_with_handler
+            expect(client).to receive :write_with_handler
             subject.write Command::Join.new(:mixer_name => 'foomixer')
           end
 
@@ -432,12 +441,12 @@ module Punchblock
           let(:active_speaker_event) { import_stanza active_speaker_xml }
 
           it "should tag those events with a mixer name, rather than a call ID" do
-            mock_event_handler.should_receive(:call).once.with do |event|
-              event.should be_instance_of Event::StartedSpeaking
-              event.target_mixer_name.should be == 'foomixer'
-              event.target_call_id.should be nil
-              event.domain.should be == 'rayo.net'
-            end
+            expect(mock_event_handler).to receive(:call).once.with { |event|
+              expect(event).to be_instance_of Event::StartedSpeaking
+              expect(event.target_mixer_name).to eq('foomixer')
+              expect(event.target_call_id).to be nil
+              expect(event.domain).to eq('rayo.net')
+            }
             connection.__send__ :handle_presence, active_speaker_event
           end
         end