adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/call_spec.rb

@@ -32,7 +32,7 @@ module Adhearsion
     subject { Adhearsion::Call.new offer }
 
     before do
-      offer.stub(:client).and_return(mock_client)
+      allow(offer).to receive(:client).and_return(mock_client)
     end
 
     after do
@@ -50,49 +50,91 @@ module Adhearsion
       foo = :bar
       subject.after(1) { foo = :baz }
       sleep 1.1
-      foo.should == :baz
+      expect(foo).to eq(:baz)
     end
 
-    it { should respond_to :<< }
+    it { is_expected.to respond_to :<< }
 
-    its(:end_reason) { should be == nil }
-    it { should be_active }
+    describe '#end_reason' do
+      subject { super().end_reason }
+      it { is_expected.to eq(nil) }
+    end
+    it { is_expected.to be_active }
+
+    describe '#commands' do
+      subject { super().commands }
+      it { is_expected.to be_empty }
+    end
+
+    describe '#id' do
+      subject { super().id }
+      it { is_expected.to eq(call_id) }
+    end
+
+    describe '#domain' do
+      subject { super().domain }
+      it { is_expected.to eq(domain) }
+    end
+
+    describe '#uri' do
+      subject { super().uri }
+      it { is_expected.to eq("footransport:#{call_id}@#{domain}") }
+    end
+
+    describe '#to' do
+      subject { super().to }
+      it { is_expected.to eq(to) }
+    end
 
-    its(:commands) { should be_empty }
+    describe '#from' do
+      subject { super().from }
+      it { is_expected.to eq(from) }
+    end
 
-    its(:id)      { should be == call_id }
-    its(:domain)  { should be == domain }
-    its(:uri)     { should be == "footransport:#{call_id}@#{domain}" }
-    its(:to)      { should be == to }
-    its(:from)    { should be == from }
+    describe '#auto_hangup' do
+      subject { super().auto_hangup }
+      it { is_expected.to be_truthy }
+    end
 
-    its(:auto_hangup) { should be_true }
+    describe '#after_hangup_lifetime' do
+      subject { super().after_hangup_lifetime }
+      it { is_expected.to eq(nil) }
+    end
 
     context "when the ID is nil" do
       let(:call_id) { nil }
 
-      its(:uri) { should be == nil }
+      describe '#uri' do
+        subject { super().uri }
+        it { is_expected.to eq(nil) }
+      end
     end
 
     context "when the domain is nil" do
       let(:domain) { nil }
 
-      its(:uri) { should be == "footransport:#{call_id}" }
+      describe '#uri' do
+        subject { super().uri }
+        it { is_expected.to eq("footransport:#{call_id}") }
+      end
     end
 
     context "when the transport is nil" do
       let(:transport) { nil }
 
-      its(:uri) { should be == "#{call_id}@#{domain}" }
+      describe '#uri' do
+        subject { super().uri }
+        it { is_expected.to eq("#{call_id}@#{domain}") }
+      end
     end
 
     it "should mark its start time" do
-      subject.start_time.should == base_time
+      expect(subject.start_time).to eq(base_time)
     end
 
     describe "#commands" do
       it "should use a duplicating accessor for the command registry" do
-        subject.commands.should_not be subject.commands
+        expect(subject.commands).not_to be subject.commands
       end
     end
 
@@ -100,15 +142,19 @@ module Adhearsion
       context "with an offer" do
         context "with headers" do
           let(:headers)   { {'X-foo' => 'bar'} }
-          its(:variables) { should be == {'x_foo' => 'bar'} }
+
+          describe '#variables' do
+            subject { super().variables }
+            it { is_expected.to eq({'x_foo' => 'bar'}) }
+          end
 
           it "should be made available via []" do
-            subject[:x_foo].should be == 'bar'
+            expect(subject[:x_foo]).to eq('bar')
           end
 
           it "should be alterable using []=" do
             subject[:x_foo] = 'baz'
-            subject[:x_foo].should be == 'baz'
+            expect(subject[:x_foo]).to eq('baz')
           end
 
           context "when receiving an event with headers" do
@@ -116,7 +162,7 @@ module Adhearsion
 
             it "should merge later headers" do
               subject << event
-              subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
+              expect(subject.variables).to eq({'x_foo' => 'bar', 'x_bar' => 'foo'})
             end
 
             context "with have symbol names" do
@@ -124,7 +170,7 @@ module Adhearsion
 
               it "should merge later headers" do
                 subject << event
-                subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
+                expect(subject.variables).to eq({'x_foo' => 'bar', 'x_bar' => 'foo'})
               end
             end
           end
@@ -134,26 +180,34 @@ module Adhearsion
 
             it "should merge later headers" do
               subject.write_command command
-              subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
+              expect(subject.variables).to eq({'x_foo' => 'bar', 'x_bar' => 'foo'})
             end
           end
         end
 
         context "without headers" do
           let(:headers)   { nil }
-          its(:variables) { should be == {} }
+
+          describe '#variables' do
+            subject { super().variables }
+            it { is_expected.to eq({}) }
+          end
         end
       end
 
       context "without an offer" do
         let(:offer)     { nil }
-        its(:variables) { should be == {} }
+
+        describe '#variables' do
+          subject { super().variables }
+          it { is_expected.to eq({}) }
+        end
       end
     end
 
     describe 'without an offer' do
       it 'should not raise an exception' do
-        lambda { Adhearsion::Call.new }.should_not raise_error
+        expect { Adhearsion::Call.new }.not_to raise_error
       end
     end
 
@@ -162,8 +216,8 @@ module Adhearsion
       let(:response)  { double 'Response' }
 
       it 'are called when messages are delivered' do
-        event.should_receive(:foo?).and_return true
-        response.should_receive(:call).once
+        expect(event).to receive(:foo?).and_return true
+        expect(response).to receive(:call).once
         subject.register_event_handler(:foo?) { response.call }
         subject << event
       end
@@ -172,18 +226,18 @@ module Adhearsion
         it 'does not cause the call actor to crash' do
           subject.register_event_handler { raise 'Boom' }
           subject << event
-          subject.should be_alive
+          expect(subject).to be_alive
         end
 
         it "triggers an exception event" do
           e = StandardError.new('Boom')
-          Events.should_receive(:trigger).once.with(:exception, [e, subject.logger])
+          expect(Events).to receive(:trigger).once.with(:exception, [e, subject.logger])
           subject.register_event_handler { raise e }
           subject << event
         end
 
         it 'executes all handlers for each event' do
-          response.should_receive(:call).once
+          expect(response).to receive(:call).once
           subject.register_event_handler { raise 'Boom' }
           subject.register_event_handler { response.call }
           subject << event
@@ -201,33 +255,33 @@ module Adhearsion
           end
 
           it "should trigger any on_joined callbacks set for the matching call ID" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_joined(:call_uri => 'footransport:foobar@rayo.net') { |event| response.call event }
             subject << event
           end
 
           it "should trigger any on_joined callbacks set for the matching call ID as a string" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_joined('foobar') { |event| response.call event }
             subject << event
           end
 
           it "should trigger any on_joined callbacks set for the matching call" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             call = Call.new
-            call.wrapped_object.stub id: 'foobar', domain: 'rayo.net', transport: 'footransport'
+            allow(call.wrapped_object).to receive_messages id: 'foobar', domain: 'rayo.net', transport: 'footransport'
             subject.on_joined(call) { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_joined callbacks for other call IDs" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined(:call_uri => 'barfoo') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_joined callbacks for mixers" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
             subject << event
           end
@@ -239,33 +293,33 @@ module Adhearsion
           end
 
           it "should trigger on_joined callbacks for the matching mixer name" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_joined callbacks for other mixer names" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined(:mixer_name => 'barfoo') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_joined callbacks set for calls" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined(:call_uri => 'foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_joined callbacks set for the matching call ID as a string" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined('foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_joined callbacks set for the matching call" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             call = Call.new
-            call.wrapped_object.stub :id => 'foobar'
+            allow(call.wrapped_object).to receive_messages :id => 'foobar'
             subject.on_joined(call) { |event| response.call event }
             subject << event
           end
@@ -279,33 +333,33 @@ module Adhearsion
           end
 
           it "should trigger any on_unjoined callbacks set for the matching call ID" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_unjoined(:call_uri => 'footransport:foobar@rayo.net') { |event| response.call event }
             subject << event
           end
 
           it "should trigger any on_unjoined callbacks set for the matching call ID as a string" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_unjoined('foobar') { |event| response.call event }
             subject << event
           end
 
           it "should trigger any on_unjoined callbacks set for the matching call" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             call = Call.new
-            call.wrapped_object.stub id: 'foobar', domain: 'rayo.net', transport: 'footransport'
+            allow(call.wrapped_object).to receive_messages id: 'foobar', domain: 'rayo.net', transport: 'footransport'
             subject.on_unjoined(call) { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_unjoined callbacks for other call IDs" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_unjoined(:call_uri => 'barfoo') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_unjoined callbacks for mixers" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
             subject << event
           end
@@ -317,33 +371,33 @@ module Adhearsion
           end
 
           it "should trigger on_unjoined callbacks for the matching mixer name" do
-            response.should_receive(:call).once.with(event)
+            expect(response).to receive(:call).once.with(event)
             subject.on_unjoined(:mixer_name => 'foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger on_unjoined callbacks for other mixer names" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_unjoined(:mixer_name => 'barfoo') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_unjoined callbacks set for calls" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_unjoined(:call_uri => 'foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_unjoined callbacks set for the matching call ID as a string" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             subject.on_unjoined('foobar') { |event| response.call event }
             subject << event
           end
 
           it "should not trigger any on_unjoined callbacks set for the matching call" do
-            response.should_receive(:call).never
+            expect(response).to receive(:call).never
             call = Call.new
-            call.wrapped_object.stub :id => 'foobar'
+            allow(call.wrapped_object).to receive_messages :id => 'foobar'
             subject.on_unjoined(call) { |event| response.call event }
             subject << event
           end
@@ -356,7 +410,7 @@ module Adhearsion
         end
 
         it "should trigger any on_end callbacks set" do
-          response.should_receive(:call).once.with(event)
+          expect(response).to receive(:call).once.with(event)
           subject.on_end { |event| response.call event }
           subject << event
         end
@@ -365,21 +419,21 @@ module Adhearsion
       context "when raising an exception" do
         it "does not kill the call actor" do
           subject.register_event_handler { |e| raise 'foo' }
-          lambda { subject << :foo }.should_not raise_error
+          expect { subject << :foo }.not_to raise_error
           sleep 1
-          subject.should be_alive
+          expect(subject).to be_alive
         end
 
         it 'passes the exception through the Events system' do
           latch = CountDownLatch.new 1
           Adhearsion::Events.exception do |e, l|
-            e.should be_a RuntimeError
-            l.should be subject.logger
+            expect(e).to be_a RuntimeError
+            expect(l).to be subject.logger
             latch.countdown!
           end
           subject.register_event_handler { |e| raise 'foo' }
-          lambda { subject << :foo }.should_not raise_error
-          latch.wait(3).should be true
+          expect { subject << :foo }.not_to raise_error
+          expect(latch.wait(3)).to be true
           Adhearsion::Events.clear_handlers :exception
         end
       end
@@ -389,7 +443,7 @@ module Adhearsion
       let(:other_call_uri) { 'xmpp:foobar@example.com' }
       let(:other_call) { Call.new }
 
-      before { other_call.stub uri: other_call_uri }
+      before { allow(other_call).to receive_messages uri: other_call_uri }
 
       let :joined_event do
         Punchblock::Event::Joined.new call_uri: other_call_uri
@@ -405,7 +459,7 @@ module Adhearsion
 
         it "should add the peer to its registry" do
           subject << joined_event
-          subject.peers.should == {'xmpp:foobar@example.com' => other_call}
+          expect(subject.peers).to eq({'xmpp:foobar@example.com' => other_call})
         end
 
         context "in a handler for the joined event" do
@@ -418,7 +472,7 @@ module Adhearsion
 
             subject << joined_event
 
-            peer.should == other_call_uri
+            expect(peer).to eq(other_call_uri)
           end
         end
 
@@ -426,9 +480,9 @@ module Adhearsion
           before { subject << joined_event }
 
           it "should remove the peer from its registry" do
-            subject.peers.should_not eql({})
+            expect(subject.peers).not_to eql({})
             subject << unjoined_event
-            subject.peers.should eql({})
+            expect(subject.peers).to eql({})
           end
 
           context "in a handler for the unjoined event" do
@@ -441,7 +495,7 @@ module Adhearsion
 
               subject << unjoined_event
 
-              peer_count.should == 0
+              expect(peer_count).to eq(0)
             end
           end
         end
@@ -450,7 +504,7 @@ module Adhearsion
       context "when we don't know about the joined call" do
         it "should add a nil entry to its registry" do
           subject << joined_event
-          subject.peers.should == {'xmpp:foobar@example.com' => nil}
+          expect(subject.peers).to eq({'xmpp:foobar@example.com' => nil})
         end
 
         context "in a handler for the joined event" do
@@ -463,7 +517,7 @@ module Adhearsion
 
             subject << joined_event
 
-            peer.should == other_call_uri
+            expect(peer).to eq(other_call_uri)
           end
         end
 
@@ -471,9 +525,9 @@ module Adhearsion
           before { subject << joined_event }
 
           it "should remove the peer from its registry" do
-            subject.peers.should_not eql({})
+            expect(subject.peers).not_to eql({})
             subject << unjoined_event
-            subject.peers.should eql({})
+            expect(subject.peers).to eql({})
           end
 
           context "in a handler for the unjoined event" do
@@ -486,14 +540,14 @@ module Adhearsion
 
               subject << unjoined_event
 
-              peer_count.should == 0
+              expect(peer_count).to eq(0)
             end
           end
         end
       end
 
       it "should not return the same registry every call" do
-        subject.peers.should_not be subject.peers
+        expect(subject.peers).not_to be subject.peers
       end
     end
 
@@ -505,25 +559,25 @@ module Adhearsion
 
         it "should mark the call as ended" do
           subject << end_event
-          subject.should_not be_active
+          expect(subject).not_to be_active
         end
 
         it "should set the end reason" do
           subject << end_event
-          subject.end_reason.should be == :hangup
+          expect(subject.end_reason).to eq(:hangup)
         end
 
         it "should set the end code" do
           subject << end_event
-          subject.end_code.should be == 'arbitrary_code'
+          expect(subject.end_code).to eq('arbitrary_code')
         end
 
         it "should set the end time" do
           finish_time = Time.local(2008, 9, 1, 12, 1, 3)
           Timecop.freeze finish_time
-          subject.end_time.should == nil
+          expect(subject.end_time).to eq(nil)
           subject << end_event
-          subject.end_time.should == finish_time
+          expect(subject.end_time).to eq(finish_time)
         end
 
         it "should set the call duration" do
@@ -534,7 +588,7 @@ module Adhearsion
           mid_point_time = Time.local(2008, 9, 1, 12, 0, 37)
           Timecop.freeze mid_point_time
 
-          subject.duration.should == 37.0
+          expect(subject.duration).to eq(37.0)
 
           finish_time = Time.local(2008, 9, 1, 12, 1, 3)
           Timecop.freeze finish_time
@@ -544,7 +598,7 @@ module Adhearsion
           future_time = Time.local(2008, 9, 1, 12, 2, 3)
           Timecop.freeze finish_time
 
-          subject.duration.should == 63.0
+          expect(subject.duration).to eq(63.0)
         end
 
         it "should instruct the command registry to terminate" do
@@ -552,25 +606,58 @@ module Adhearsion
           command.request!
           subject.future.write_and_await_response command
           subject << end_event
-          command.response(1).should be_a Call::Hangup
+          expect(command.response(1)).to be_a Call::Hangup
         end
 
         it "removes itself from the active calls" do
           size_before = Adhearsion.active_calls.size
 
           Adhearsion.active_calls << subject
-          Adhearsion.active_calls.size.should be > size_before
+          expect(Adhearsion.active_calls.size).to be > size_before
 
           subject << end_event
-          Adhearsion.active_calls.size.should be == size_before
+          expect(Adhearsion.active_calls.size).to eq(size_before)
         end
 
-        it "shuts down the actor" do
-          Adhearsion.config.platform.after_hangup_lifetime = 2
-          subject << end_event
-          sleep 2.1
-          subject.should_not be_alive
-          lambda { subject.id }.should raise_error Call::ExpiredError, /expired and is no longer accessible/
+        context "with no custom lifetime" do
+          around do |example|
+            old_val = Adhearsion.config.platform.after_hangup_lifetime
+            begin
+              example.run
+            rescue
+              Adhearsion.config.platform.after_hangup_lifetime = old_val
+            end
+          end
+
+          it "shuts down the actor using platform config" do
+            Adhearsion.config.platform.after_hangup_lifetime = 2
+            subject << end_event
+            sleep 2.1
+            expect(subject.alive?).to be false
+            expect { subject.id }.to raise_error Call::ExpiredError, /expired and is no longer accessible/
+          end
+        end
+
+        context "with a custom lifetime" do
+          around do |example|
+            old_val = Adhearsion.config.platform.after_hangup_lifetime
+            begin
+              example.run
+            rescue
+              Adhearsion.config.platform.after_hangup_lifetime = old_val
+            end
+          end
+
+          it "shuts down the actor using the Call#after_hangup_lifetime" do
+            Adhearsion.config.platform.after_hangup_lifetime = 1
+            subject.after_hangup_lifetime = 2
+            subject << end_event
+            sleep 1.1
+            expect(subject.alive?).to be true
+            sleep 1
+            expect(subject.alive?).to be false
+            expect { subject.id }.to raise_error Call::ExpiredError, /expired and is no longer accessible/
+          end
         end
       end
     end
@@ -584,7 +671,7 @@ module Adhearsion
         before { subject << end_event }
 
         it "should return the end reason" do
-          subject.wait_for_end.should == :hangup
+          expect(subject.wait_for_end).to eq(:hangup)
         end
       end
 
@@ -593,35 +680,35 @@ module Adhearsion
           fut = subject.future.wait_for_end
 
           sleep 0.5
-          fut.should_not be_ready
+          expect(fut).not_to be_ready
 
           subject << end_event
 
-          fut.value.should == :hangup
+          expect(fut.value).to eq(:hangup)
         end
       end
     end
 
     describe "tagging a call" do
       it 'with a single Symbol' do
-        lambda {
+        expect {
           subject.tag :moderator
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it 'with multiple Symbols' do
-        lambda {
+        expect {
           subject.tag :moderator
           subject.tag :female
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it 'with a non-Symbol, non-String object' do
         bad_objects = [123, Object.new, 888.88, nil, true, false, StringIO.new]
         bad_objects.each do |bad_object|
-          lambda {
+          expect {
             subject.tag bad_object
-          }.should raise_error ArgumentError
+          }.to raise_error ArgumentError
         end
       end
     end
@@ -631,21 +718,21 @@ module Adhearsion
       subject.tag :female
       subject.remove_tag :female
       subject.tag :male
-      subject.tags.should be == [:moderator, :male]
+      expect(subject.tags).to eq([:moderator, :male])
     end
 
     describe "#tagged_with?" do
       it 'with one tag' do
         subject.tag :guest
-        subject.tagged_with?(:guest).should be true
-        subject.tagged_with?(:authorized).should be false
+        expect(subject.tagged_with?(:guest)).to be true
+        expect(subject.tagged_with?(:authorized)).to be false
       end
 
       it 'with many tags' do
         subject.tag :customer
         subject.tag :authorized
-        subject.tagged_with?(:customer).should be true
-        subject.tagged_with?(:authorized).should be true
+        expect(subject.tagged_with?(:customer)).to be true
+        expect(subject.tagged_with?(:authorized)).to be true
       end
     end
 
@@ -653,25 +740,25 @@ module Adhearsion
       let(:command) { Punchblock::Command::Answer.new }
 
       it "should write the command to the Punchblock connection" do
-        subject.wrapped_object.should_receive(:client).once.and_return mock_client
-        mock_client.should_receive(:execute_command).once.with(Punchblock::Command::Answer.new(target_call_id: call_id, domain: domain)).and_return true
+        expect(subject.wrapped_object).to receive(:client).once.and_return mock_client
+        expect(mock_client).to receive(:execute_command).once.with(Punchblock::Command::Answer.new(target_call_id: call_id, domain: domain)).and_return true
         subject.write_command command
       end
 
       describe "with a hungup call" do
         before do
-          subject.wrapped_object.should_receive(:active?).and_return(false)
+          expect(subject.wrapped_object).to receive(:active?).and_return(false)
         end
 
         it "should raise a Hangup exception" do
-          lambda { subject.write_command command }.should raise_error(Call::Hangup)
+          expect { subject.write_command command }.to raise_error(Call::Hangup)
         end
 
         describe "if the command is a Hangup" do
           let(:command) { Punchblock::Command::Hangup.new }
 
           it "should not raise a Hangup exception" do
-            lambda { subject.write_command command }.should_not raise_error
+            expect { subject.write_command command }.not_to raise_error
           end
         end
       end
@@ -682,18 +769,18 @@ module Adhearsion
       let(:response) { :foo }
 
       before do
-        message.should_receive(:execute!).and_return true
+        expect(message).to receive(:execute!).and_return true
         message.response = response
       end
 
       it "writes a command to the call" do
-        subject.wrapped_object.should_receive(:write_command).once.with(message)
+        expect(subject.wrapped_object).to receive(:write_command).once.with(message)
         subject.write_and_await_response message
       end
 
       it "removes the command from the registry after execution" do
         subject.write_and_await_response message
-        subject.commands.should be_empty
+        expect(subject.commands).to be_empty
       end
 
       it "blocks until a response is received" do
@@ -705,7 +792,7 @@ module Adhearsion
         end
         starting_time = Time.now
         subject.write_and_await_response slow_command
-        (Time.now - starting_time).should >= 0.5
+        expect(Time.now - starting_time).to be >= 0.5
       end
 
       context "while waiting for a response" do
@@ -715,7 +802,7 @@ module Adhearsion
 
         it "does not block the whole actor while waiting for a response" do
           fut = subject.future.write_and_await_response slow_command
-          subject.id.should == call_id
+          expect(subject.id).to eq(call_id)
           slow_command.response = response
           fut.value
         end
@@ -723,14 +810,14 @@ module Adhearsion
         it "adds the command to the registry" do
           subject.future.write_and_await_response slow_command
           sleep 0.2
-          subject.commands.should_not be_empty
-          subject.commands.first.should be slow_command
+          expect(subject.commands).not_to be_empty
+          expect(subject.commands.first).to be slow_command
         end
       end
 
       describe "with a successful response" do
         it "returns the executed command" do
-          subject.write_and_await_response(message).should be message
+          expect(subject.write_and_await_response(message)).to be message
         end
       end
 
@@ -739,16 +826,16 @@ module Adhearsion
         let(:response) { new_exception.new }
 
         it "raises the error" do
-          Events.should_receive(:trigger).never
-          lambda { subject.write_and_await_response message }.should raise_error new_exception
+          expect(Events).to receive(:trigger).never
+          expect { subject.write_and_await_response message }.to raise_error new_exception
         end
 
         context "where the name is :item_not_found" do
           let(:response) { new_exception.new.setup :item_not_found }
 
           it "should raise a Hangup exception" do
-            Events.should_receive(:trigger).never
-            lambda { subject.write_and_await_response message }.should raise_error Call::Hangup
+            expect(Events).to receive(:trigger).never
+            expect { subject.write_and_await_response message }.to raise_error Call::Hangup
           end
         end
       end
@@ -757,34 +844,34 @@ module Adhearsion
         before do
           message.target_call_id = call_id
           message.domain = domain
-          message.should_receive(:response).and_raise Timeout::Error
+          expect(message).to receive(:response).and_raise Timeout::Error
         end
 
         it "should raise the error in the caller but not crash the actor" do
-          lambda { subject.write_and_await_response message }.should raise_error Call::CommandTimeout, message.to_s
+          expect { subject.write_and_await_response message }.to raise_error Call::CommandTimeout, message.to_s
           sleep 0.5
-          subject.should be_alive
+          expect(subject).to be_alive
         end
       end
     end
 
     describe "#send_message" do
       it "should send a message through the Punchblock connection using the call ID and domain" do
-        subject.wrapped_object.should_receive(:client).once.and_return mock_client
-        mock_client.should_receive(:send_message).once.with(subject.id, subject.domain, "Hello World!", {})
+        expect(subject.wrapped_object).to receive(:client).once.and_return mock_client
+        expect(mock_client).to receive(:send_message).once.with(subject.id, subject.domain, "Hello World!", {})
         subject.send_message "Hello World!"
       end
 
       it "should send a message with the given subject" do
-        subject.wrapped_object.should_receive(:client).once.and_return mock_client
-        mock_client.should_receive(:send_message).once.with(subject.id, subject.domain, nil, :subject => "Important Message")
+        expect(subject.wrapped_object).to receive(:client).once.and_return mock_client
+        expect(mock_client).to receive(:send_message).once.with(subject.id, subject.domain, nil, :subject => "Important Message")
         subject.send_message nil, :subject => "Important Message"
       end
     end
 
     describe "basic control commands" do
       def expect_message_waiting_for_response(message = nil, fail = false, &block)
-        expectation = subject.wrapped_object.should_receive(:write_and_await_response, &block).once
+        expectation = expect(subject.wrapped_object).to receive(:write_and_await_response, &block).once
         expectation = expectation.with message if message
         if fail
           expectation.and_raise fail
@@ -816,6 +903,16 @@ module Adhearsion
             subject.accept
           end
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Accept.new, error
+            expect { subject.accept }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe '#answer' do
@@ -833,6 +930,16 @@ module Adhearsion
             subject.answer headers
           end
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Answer.new, error
+            expect { subject.answer }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe '#reject' do
@@ -871,20 +978,74 @@ module Adhearsion
 
         it "should immediately fire the :call_rejected event giving the call and the reason" do
           expect_message_waiting_for_response kind_of(Punchblock::Command::Reject)
-          Adhearsion::Events.should_receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
+          expect(Adhearsion::Events).to receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
           subject.reject :decline
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Reject.new(reason: :busy), error
+            expect { subject.reject }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
+      end
+
+      describe '#redirect' do
+        describe "with a target given" do
+          it 'should send a Redirect message with the correct target' do
+            expect_message_waiting_for_response Punchblock::Command::Redirect.new(to: 'sip:foo@bar.com')
+            subject.redirect 'sip:foo@bar.com'
+          end
+        end
+
+        describe "with no target given" do
+          it 'should raise with ArgumentError' do
+            expect { subject.redirect }.to raise_error(ArgumentError)
+          end
+        end
+
+        describe "with no headers" do
+          it 'should send a Redirect message' do
+            expect_message_waiting_for_response do |c|
+              c.is_a?(Punchblock::Command::Redirect) && c.headers == {}
+            end
+            subject.redirect 'sip:foo@bar.com'
+          end
+        end
+
+        describe "with headers set" do
+          it 'should send a Redirect message with the correct headers' do
+            headers = {:foo => 'bar'}
+            expect_message_waiting_for_response do |c|
+              c.is_a?(Punchblock::Command::Redirect) && c.headers == headers
+            end
+            subject.redirect 'sip:foo@bar.com', headers
+          end
+        end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Redirect.new(to: 'sip:foo@bar.com'), error
+            expect { subject.redirect 'sip:foo@bar.com' }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe "#hangup" do
         describe "if the call is not active" do
           before do
-            subject.wrapped_object.should_receive(:active?).and_return false
+            expect(subject.wrapped_object).to receive(:active?).and_return false
           end
 
           it "should do nothing and return false" do
-            subject.should_receive(:write_and_await_response).never
-            subject.hangup.should be false
+            expect(subject).to receive(:write_and_await_response).never
+            expect(subject.hangup).to be false
           end
         end
 
@@ -892,7 +1053,7 @@ module Adhearsion
           it "should mark the call inactive" do
             expect_message_waiting_for_response Punchblock::Command::Hangup.new
             subject.hangup
-            subject.should_not be_active
+            expect(subject).not_to be_active
           end
 
           describe "with no headers" do
@@ -910,6 +1071,16 @@ module Adhearsion
             end
           end
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Hangup.new, error
+            expect { subject.hangup }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe "#join" do
@@ -925,7 +1096,7 @@ module Adhearsion
           let(:uri)     { "footransport:#{call_id}@#{domain}" }
           let(:target)  { described_class.new }
 
-          before { target.wrapped_object.stub uri: uri }
+          before { allow(target.wrapped_object).to receive_messages uri: uri }
 
           it "should send a join command joining to the provided call ID" do
             expect_join_with_options call_uri: uri
@@ -942,45 +1113,45 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
-            result[:command].should be_a Punchblock::Command::Join
-            result[:command].call_uri.should eql(uri)
-            result[:command].media.should eql(:bridge)
-            result[:command].direction.should eql(:recv)
+            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command].call_uri).to eql(uri)
+            expect(result[:command].media).to eql(:bridge)
+            expect(result[:command].direction).to eql(:recv)
           end
 
           it "should return something that can be blocked on until the join is complete" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:joined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:joined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
           it "should return something that can be blocked on until the entities are unjoined" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Unjoined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should unblock all conditions on call end if no joined/unjoined events are received" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:joined_condition].wait(0.5).should be_false
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::End.new
-            result[:joined_condition].wait(0.5).should be_true
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should not error on call end when joined/unjoined events are received correctly" do
@@ -1000,7 +1171,7 @@ module Adhearsion
             subject << Punchblock::Event::Joined.new(call_uri: uri)
             subject << Punchblock::Event::Joined.new(call_uri: uri)
 
-            subject.should be_alive
+            expect(subject).to be_alive
           end
         end
 
@@ -1023,45 +1194,45 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
-            result[:command].should be_a Punchblock::Command::Join
-            result[:command].call_uri.should eql(uri)
-            result[:command].media.should eql(:bridge)
-            result[:command].direction.should eql(:recv)
+            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command].call_uri).to eql(uri)
+            expect(result[:command].media).to eql(:bridge)
+            expect(result[:command].direction).to eql(:recv)
           end
 
           it "should return something that can be blocked on until the join is complete" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:joined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:joined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
           it "should return something that can be blocked on until the entities are unjoined" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Unjoined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should unblock all conditions on call end if no joined/unjoined events are received" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            result[:joined_condition].wait(0.5).should be_false
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::End.new
-            result[:joined_condition].wait(0.5).should be_true
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should not error on call end when joined/unjoined events are received correctly" do
@@ -1081,7 +1252,7 @@ module Adhearsion
             subject << Punchblock::Event::Joined.new(call_uri: uri)
             subject << Punchblock::Event::Joined.new(call_uri: uri)
 
-            subject.should be_alive
+            expect(subject).to be_alive
           end
         end
 
@@ -1105,45 +1276,45 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
-            result[:command].should be_a Punchblock::Command::Join
-            result[:command].call_uri.should eql(uri)
-            result[:command].media.should eql(:bridge)
-            result[:command].direction.should eql(:recv)
+            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command].call_uri).to eql(uri)
+            expect(result[:command].media).to eql(:bridge)
+            expect(result[:command].direction).to eql(:recv)
           end
 
           it "should return something that can be blocked on until the join is complete" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:joined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:joined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
           it "should return something that can be blocked on until the entities are unjoined" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Unjoined.new(call_uri: uri)
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should unblock all conditions on call end if no joined/unjoined events are received" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:joined_condition].wait(0.5).should be_false
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::End.new
-            result[:joined_condition].wait(0.5).should be_true
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should not error on call end when joined/unjoined events are received correctly" do
@@ -1163,7 +1334,7 @@ module Adhearsion
             subject << Punchblock::Event::Joined.new(call_uri: uri)
             subject << Punchblock::Event::Joined.new(call_uri: uri)
 
-            subject.should be_alive
+            expect(subject).to be_alive
           end
         end
 
@@ -1186,45 +1357,45 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
-            result[:command].should be_a Punchblock::Command::Join
-            result[:command].mixer_name.should eql(mixer_name)
-            result[:command].media.should eql(:bridge)
-            result[:command].direction.should eql(:recv)
+            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command].mixer_name).to eql(mixer_name)
+            expect(result[:command].media).to eql(:bridge)
+            expect(result[:command].direction).to eql(:recv)
           end
 
           it "should return something that can be blocked on until the join is complete" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:joined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
-            result[:joined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
           it "should return something that can be blocked on until the entities are unjoined" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::Unjoined.new(mixer_name: mixer_name)
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should unblock all conditions on call end if no joined/unjoined events are received" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            result[:joined_condition].wait(0.5).should be_false
-            result[:unjoined_condition].wait(0.5).should be_false
+            expect(result[:joined_condition].wait(0.5)).to be_falsey
+            expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
             subject << Punchblock::Event::End.new
-            result[:joined_condition].wait(0.5).should be_true
-            result[:unjoined_condition].wait(0.5).should be_true
+            expect(result[:joined_condition].wait(0.5)).to be_truthy
+            expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
           it "should not error on call end when joined/unjoined events are received correctly" do
@@ -1244,7 +1415,7 @@ module Adhearsion
             subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
             subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
 
-            subject.should be_alive
+            expect(subject).to be_alive
           end
         end
 
@@ -1254,7 +1425,17 @@ module Adhearsion
           let(:target)      { { :call_uri => call_id, :mixer_name => mixer_name } }
 
           it "should raise an ArgumentError" do
-            lambda { subject.join target }.should raise_error ArgumentError, /call URI and mixer name/
+            expect { subject.join target }.to raise_error ArgumentError, /call URI and mixer name/
+          end
+        end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Join.new(call_id: 'footransport:foo@rayo.net'), error
+            expect { subject.join 'foo' }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
           end
         end
       end
@@ -1266,13 +1447,20 @@ module Adhearsion
           end
         end
 
+        context "without a target" do
+          it "should send an unjoin command unjoining from every existing join" do
+            expect_unjoin_with_options nil
+            subject.unjoin
+          end
+        end
+
         context "with a call" do
           let(:call_id) { rand.to_s }
           let(:domain)  { 'rayo.net' }
           let(:uri)     { "footransport:#{call_id}@#{domain}" }
           let(:target)  { described_class.new }
 
-          before { target.wrapped_object.stub uri: uri }
+          before { allow(target.wrapped_object).to receive_messages uri: uri }
 
           it "should send an unjoin command unjoining from the provided call ID" do
             expect_unjoin_with_options call_uri: "footransport:#{call_id}@#{domain}"
@@ -1315,7 +1503,17 @@ module Adhearsion
           let(:target)      { { call_uri: call_id, mixer_name: mixer_name } }
 
           it "should raise an ArgumentError" do
-            lambda { subject.unjoin target }.should raise_error ArgumentError, /call URI and mixer name/
+            expect { subject.unjoin target }.to raise_error ArgumentError, /call URI and mixer name/
+          end
+        end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Unjoin.new(call_id: 'footransport:foo@rayo.net'), error
+            expect { subject.unjoin 'foo' }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
           end
         end
       end
@@ -1325,6 +1523,16 @@ module Adhearsion
           expect_message_waiting_for_response Punchblock::Command::Mute.new
           subject.mute
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Mute.new, error
+            expect { subject.mute }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe "#unmute" do
@@ -1332,6 +1540,16 @@ module Adhearsion
           expect_message_waiting_for_response Punchblock::Command::Unmute.new
           subject.unmute
         end
+
+        context "with a failure response" do
+          it 'should raise the error but not crash the actor' do
+            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Punchblock::Command::Unmute.new, error
+            expect { subject.unmute }.to raise_error error
+            sleep 0.2
+            expect(subject.alive?).to be true
+          end
+        end
       end
 
       describe "#execute_controller" do
@@ -1339,52 +1557,59 @@ module Adhearsion
         let(:mock_controller) { CallController.new(subject) }
 
         before do
-          subject.wrapped_object.stub :write_and_await_response => true
+          allow(subject.wrapped_object).to receive_messages :write_and_await_response => true
         end
 
         it "should call #bg_exec on the controller instance" do
-          mock_controller.should_receive(:exec).once
+          expect(mock_controller).to receive(:exec).once
           subject.execute_controller mock_controller, lambda { |call| latch.countdown! }
-          latch.wait(3).should be_true
+          expect(latch.wait(3)).to be_truthy
         end
 
         it "should use the passed block as a controller if none is specified" do
-          mock_controller.should_receive(:exec).once
-          CallController.should_receive(:new).once.and_return mock_controller
+          expect(mock_controller).to receive(:exec).once
+          expect(CallController).to receive(:new).once.and_return mock_controller
           subject.execute_controller nil, lambda { |call| latch.countdown! } do
             foo
           end
-          latch.wait(3).should be_true
+          expect(latch.wait(3)).to be_truthy
         end
 
         it "should raise ArgumentError if both a controller and a block are passed" do
-          lambda { subject.execute_controller(mock_controller) { foo } }.should raise_error(ArgumentError)
+          expect { subject.execute_controller(mock_controller) { foo } }.to raise_error(ArgumentError)
         end
 
         it "should pass the exception to the events system" do
           latch = CountDownLatch.new 1
           Adhearsion::Events.exception do |e, l|
-            e.should be_a RuntimeError
-            l.should be subject.logger
+            expect(e).to be_a RuntimeError
+            expect(l).to be subject.logger
             latch.countdown!
           end
           subject.execute_controller BrokenController.new(subject), lambda { |call| latch.countdown! }
-          latch.wait(3).should be true
+          expect(latch.wait(3)).to be true
           Adhearsion::Events.clear_handlers :exception
         end
 
         it "should execute a callback after the controller executes" do
           foo = nil
           subject.execute_controller mock_controller, lambda { |call| foo = call; latch.countdown! }
-          latch.wait(3).should be_true
-          foo.should be subject
+          expect(latch.wait(3)).to be_truthy
+          expect(foo).to be subject
+        end
+
+        it "should prevent exceptions in controllers from being raised" do
+          expect(mock_controller).to receive(:run).once.ordered.and_raise StandardError
+          expect { subject.execute_controller mock_controller, lambda { |call| latch.countdown! } }.to_not raise_error
+          expect(latch.wait(3)).to be_truthy
+          expect(subject.alive?).to be true
         end
       end
 
       describe "#register_controller" do
         it "should add the controller to a list on the call" do
           subject.register_controller :foo
-          subject.controllers.should include :foo
+          expect(subject.controllers).to include :foo
         end
       end
 
@@ -1396,8 +1621,8 @@ module Adhearsion
 
         describe "#pause_controllers" do
           it "should pause each of the registered controllers" do
-            controller1.should_receive(:pause!).once
-            controller2.should_receive(:pause!).once
+            expect(controller1).to receive(:pause!).once
+            expect(controller2).to receive(:pause!).once
 
             subject.pause_controllers
           end
@@ -1405,8 +1630,8 @@ module Adhearsion
 
         describe "#resume_controllers" do
           it "should resume each of the registered controllers" do
-            controller1.should_receive(:resume!).once
-            controller2.should_receive(:resume!).once
+            expect(controller1).to receive(:resume!).once
+            expect(controller2).to receive(:resume!).once
 
             subject.resume_controllers
           end
@@ -1417,7 +1642,7 @@ module Adhearsion
         it "should delete its logger" do
           logger = subject.logger
           subject.terminate
-          ::Logging::Repository.instance[logger.name].should be_nil
+          expect(::Logging::Repository.instance[logger.name]).to be_nil
         end
       end
     end
@@ -1425,21 +1650,21 @@ module Adhearsion
     describe Call::CommandRegistry do
       subject { Call::CommandRegistry.new }
 
-      it { should be_empty }
+      it { is_expected.to be_empty }
 
       describe "#<<" do
         it "should add a command to the registry" do
           subject << :foo
-          subject.should_not be_empty
+          expect(subject).not_to be_empty
         end
       end
 
       describe "#delete" do
         it "should remove a command from the registry" do
           subject << :foo
-          subject.should_not be_empty
+          expect(subject).not_to be_empty
           subject.delete :foo
-          subject.should be_empty
+          expect(subject).to be_empty
         end
       end
 
@@ -1462,9 +1687,9 @@ module Adhearsion
           end
           subject.terminate
           commands.each do |command|
-            command.response.should be_a Call::Hangup
+            expect(command.response).to be_a Call::Hangup
           end
-          finished_command.response.should be == :foo
+          expect(finished_command.response).to eq(:foo)
         end
       end
     end