adhearsion 2.5.4 → 2.6.0

data/lib/adhearsion/punchblock_plugin.rb

@@ -1,11 +1,10 @@
 # encoding: utf-8
 
+require 'adhearsion/plugin'
+require 'adhearsion/punchblock_plugin/initializer'
+
 module Adhearsion
   class PunchblockPlugin < Plugin
-    extend ActiveSupport::Autoload
-
-    autoload :Initializer
-
     config :punchblock do
       enabled             true             , :transform => Proc.new { |v| v == 'true' }, :desc => "Enable or disable Punchblock connectivity to a Voice server"
       platform            :xmpp            , :transform => Proc.new { |v| v.to_sym }, :desc => <<-__

data/lib/adhearsion/punchblock_plugin/initializer.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
 require 'blather'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module Adhearsion
-  class PunchblockPlugin
+  class PunchblockPlugin < Plugin
     class Initializer
       cattr_accessor :config, :client, :dispatcher, :attempts
 

data/lib/adhearsion/router.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 
+%w(
+  evented_route
+  openended_route
+  route
+  unaccepting_route
+).each { |r| require "adhearsion/router/#{r}" }
+
 module Adhearsion
   class Router
-    extend ActiveSupport::Autoload
-
-    autoload :EventedRoute
-    autoload :OpenendedRoute
-    autoload :Route
-    autoload :UnacceptingRoute
-
     NoMatchError = Class.new Adhearsion::Error
 
     attr_reader :routes

data/lib/adhearsion/router/route.rb

@@ -28,6 +28,8 @@ module Adhearsion
       def dispatch(call, callback = nil)
         Adhearsion::Events.trigger_immediately :call_routed, call: call, route: self
 
+        call_id = call.id # Grab this to use later incase the actor is dead
+
         controller = if target.respond_to?(:call)
           CallController.new call, controller_metadata, &target
         else
@@ -38,11 +40,15 @@ module Adhearsion
 
         call.execute_controller controller, lambda { |call_actor|
           begin
-            if call_actor.auto_hangup
-              logger.info "Call #{call.id} routing completed. Hanging up now."
-              call_actor.hangup
+            if call_actor.alive? && call_actor.active?
+              if call_actor.auto_hangup
+                logger.info "Call #{call_id} routing completed. Hanging up now."
+                call_actor.hangup
+              else
+                logger.info "Call #{call_id} routing completed. Keeping the call alive at controller/router request."
+              end
             else
-              logger.info "Call #{call.id} routing completed. Keeping the call alive at controller/router request."
+              logger.info "Call #{call_id} routing completed. Call was already hung up."
             end
           rescue Call::Hangup, Call::ExpiredError
           end

data/lib/adhearsion/rspec.rb

@@ -8,3 +8,5 @@ initializer.load_lib_folder
 initializer.load_config_file
 initializer.load_events_file
 initializer.load_routes_file
+initializer.start_logging
+Adhearsion::Logging.logging_level = :error

data/lib/adhearsion/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Adhearsion
-  VERSION = '2.5.4'
+  VERSION = '2.6.0'
 end

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -22,41 +22,41 @@ module Adhearsion
       let(:join_options) { options[:join_options] || {} }
 
       before do
-        other_mock_call.wrapped_object.stub id: other_call_id, write_command: true
-        second_other_mock_call.wrapped_object.stub id: second_other_call_id, write_command: true
+        allow(other_mock_call.wrapped_object).to receive_messages id: other_call_id, write_command: true
+        allow(second_other_mock_call.wrapped_object).to receive_messages id: second_other_call_id, write_command: true
       end
 
       def mock_end(reason = :hangup_command)
-        Punchblock::Event::End.new.tap { |event| event.stub reason: reason }
+        Punchblock::Event::End.new.tap { |event| allow(event).to receive_messages reason: reason }
       end
 
       describe "#dial" do
         it "should dial the call to the correct endpoint and return a dial status object" do
-          OutboundCall.should_receive(:new).and_return other_mock_call
-          other_mock_call.should_receive(:dial).with(to, :from => 'foo').once
+          expect(OutboundCall).to receive(:new).and_return other_mock_call
+          expect(other_mock_call).to receive(:dial).with(to, :from => 'foo').once
           dial_thread = Thread.new do
             status = subject.dial(to, :from => 'foo')
 
-            status.should be_a Dial::DialStatus
+            expect(status).to be_a Dial::DialStatus
             joined_status = status.joins[status.calls.first]
-            joined_status.duration.should == 0.0
-            joined_status.result.should == :no_answer
+            expect(joined_status.duration).to eq(0.0)
+            expect(joined_status.result).to eq(:no_answer)
           end
           sleep 0.1
           other_mock_call << mock_end
-          dial_thread.join.should be_true
+          expect(dial_thread.join).to be_truthy
         end
 
         it "should default the caller ID to that of the original call" do
-          call.stub :from => 'sip:foo@bar.com'
-          OutboundCall.should_receive(:new).and_return other_mock_call
-          other_mock_call.should_receive(:dial).with(to, :from => 'sip:foo@bar.com').once
+          allow(call).to receive_messages :from => 'sip:foo@bar.com'
+          expect(OutboundCall).to receive(:new).and_return other_mock_call
+          expect(other_mock_call).to receive(:dial).with(to, :from => 'sip:foo@bar.com').once
           dial_thread = Thread.new do
             subject.dial to
           end
           sleep 0.1
           other_mock_call << mock_end
-          dial_thread.join.should be_true
+          expect(dial_thread.join).to be_truthy
         end
 
         let(:options) { { :foo => :bar } }
@@ -71,61 +71,61 @@ module Adhearsion
 
         describe "without a block" do
           before do
-            other_mock_call.should_receive(:dial).once.with(to, options)
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(other_mock_call).to receive(:dial).once.with(to, options)
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
           end
 
           it "blocks the original controller until the new call ends" do
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           it "unblocks the original controller if the original call ends" do
-            other_mock_call.should_receive(:hangup).once
+            expect(other_mock_call).to receive(:hangup).once
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           it "joins the new call to the existing one on answer" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
 
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           context "with a join target specified" do
             let(:options) { { join_target: {mixer_name: 'foobar'} } }
 
             it "joins the calls to the specified target on answer" do
-              call.should_receive(:answer).once
-              call.should_receive(:join).once.with({mixer_name: 'foobar'}, {})
-              other_mock_call.should_receive(:join).once.with({mixer_name: 'foobar'}, {})
+              expect(call).to receive(:answer).once
+              expect(call).to receive(:join).once.with({mixer_name: 'foobar'}, {})
+              expect(other_mock_call).to receive(:join).once.with({mixer_name: 'foobar'}, {})
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
           end
 
@@ -134,18 +134,18 @@ module Adhearsion
             let(:options) { { pre_join: ->(call) { foo.bar call } } }
 
             it "executes the callback prior to joining" do
-              foo.should_receive(:bar).once.with(other_mock_call).ordered
-              call.should_receive(:answer).once.ordered
-              other_mock_call.should_receive(:join).once.with(call, {}).ordered
+              expect(foo).to receive(:bar).once.with(other_mock_call).ordered
+              expect(call).to receive(:answer).once.ordered
+              expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
           end
 
@@ -159,19 +159,19 @@ module Adhearsion
             end
 
             it "plays the ringback asynchronously, terminating prior to joining" do
-              subject.should_receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
-              component.should_receive(:stop!).twice
-              call.should_receive(:answer).once.ordered
-              other_mock_call.should_receive(:join).once.with(call, {}).ordered
+              expect(subject).to receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
+              expect(component).to receive(:stop!).twice
+              expect(call).to receive(:answer).once.ordered
+              expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
 
             context "as a callback" do
@@ -179,51 +179,51 @@ module Adhearsion
               let(:options) { { ringback: -> { foo.bar; component } } }
 
               it "calls the callback to start, and uses the return value of the callback to stop the ringback" do
-                foo.should_receive(:bar).once.ordered
-                component.should_receive(:stop!).twice
-                call.should_receive(:answer).once.ordered
-                other_mock_call.should_receive(:join).once.with(call, {}).ordered
+                expect(foo).to receive(:bar).once.ordered
+                expect(component).to receive(:stop!).twice
+                expect(call).to receive(:answer).once.ordered
+                expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
                 dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call << mock_answered
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
               end
             end
 
             context "when the call is rejected" do
               it "terminates the ringback before returning" do
-                subject.should_receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
-                component.should_receive(:stop!).once
+                expect(subject).to receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
+                expect(component).to receive(:stop!).once
 
                 t = dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call << mock_end(:reject)
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
               end
             end
           end
 
           it "hangs up the new call when the root call ends" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
-            other_mock_call.should_receive(:hangup).once
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
+            expect(other_mock_call).to receive(:hangup).once
 
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           context "when the call is rejected" do
@@ -234,11 +234,11 @@ module Adhearsion
 
               other_mock_call << mock_end(:reject)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :no_answer
+              expect(status.result).to eq(:no_answer)
             end
           end
 
@@ -250,22 +250,22 @@ module Adhearsion
 
               other_mock_call << mock_end(:error)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :error
+              expect(status.result).to eq(:error)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 0.0
-              joined_status.result.should == :error
+              expect(joined_status.duration).to eq(0.0)
+              expect(joined_status.result).to eq(:error)
             end
           end
 
           context "when the call is answered and joined" do
             it "has an overall dial status of :answer" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
@@ -277,23 +277,23 @@ module Adhearsion
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.result.should == :joined
+              expect(joined_status.result).to eq(:joined)
             end
 
             it "records the duration of the join" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
-              other_mock_call.stub hangup: true
+              allow(other_mock_call).to receive_messages hangup: true
 
               t = dial_in_thread
 
@@ -309,22 +309,22 @@ module Adhearsion
               other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 37.0
+              expect(joined_status.duration).to eq(37.0)
             end
 
             context "when join options are specified" do
               let(:options) { { join_options: {media: :direct} } }
 
               it "joins the calls with those options" do
-                call.should_receive(:answer).once
-                other_mock_call.should_receive(:join).once.with(call, media: :direct)
-                other_mock_call.stub hangup: true
+                expect(call).to receive(:answer).once
+                expect(other_mock_call).to receive(:join).once.with(call, media: :direct)
+                allow(other_mock_call).to receive_messages hangup: true
 
                 t = dial_in_thread
 
@@ -335,7 +335,7 @@ module Adhearsion
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 t.join
               end
@@ -346,19 +346,19 @@ module Adhearsion
             let(:join_target) { call }
 
             before do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(join_target, join_options).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(join_target, join_options) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
-              other_mock_call.stub(:unjoin).and_return do
+              allow(other_mock_call).to receive(:unjoin) do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
             end
 
             it "should unjoin the calls" do
-              other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+              expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
@@ -378,10 +378,10 @@ module Adhearsion
               dial.split
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
-              dial.status.result.should be == :answer
+              expect(dial.status.result).to eq(:answer)
             end
 
             it "should not unblock immediately" do
@@ -399,14 +399,14 @@ module Adhearsion
 
               dial.split
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
-              dial.status.result.should be == :answer
+              expect(dial.status.result).to eq(:answer)
             end
 
             it "should set end time" do
@@ -433,13 +433,13 @@ module Adhearsion
               Timecop.freeze base_time
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
               status = dial.status
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 37.0
+              expect(joined_status.duration).to eq(37.0)
             end
 
             context "with new controllers specified" do
@@ -474,32 +474,32 @@ module Adhearsion
 
                 other_mock_call << mock_answered
 
-                should_receive(:callback).once.with(call)
-                should_receive(:callback).once.with(other_mock_call)
+                expect(self).to receive(:callback).once.with(call)
+                expect(self).to receive(:callback).once.with(other_mock_call)
 
                 dial.split main: main_split_controller, others: others_split_controller, main_callback: ->(call) { self.callback(call) }, others_callback: ->(call) { self.callback(call) }
 
-                latch.wait(2).should be_false
-                split_latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_falsey
+                expect(split_latch.wait(2)).to be_truthy
 
-                call['hit_split_controller'].should == main_split_controller
-                call['split_controller_metadata']['current_dial'].should be dial
+                expect(call['hit_split_controller']).to eq(main_split_controller)
+                expect(call['split_controller_metadata']['current_dial']).to be dial
 
-                other_mock_call['hit_split_controller'].should == others_split_controller
-                other_mock_call['split_controller_metadata']['current_dial'].should be dial
+                expect(other_mock_call['hit_split_controller']).to eq(others_split_controller)
+                expect(other_mock_call['split_controller_metadata']['current_dial']).to be dial
 
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
             end
 
             context "when rejoining" do
               it "should rejoin the calls" do
-                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
@@ -518,22 +518,22 @@ module Adhearsion
 
                 dial.split
 
-                other_mock_call.should_receive(:join).once.ordered.with(call, {})
+                expect(other_mock_call).to receive(:join).once.ordered.with(call, {})
                 dial.rejoin
 
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               context "when join options were set originally" do
                 let(:options) { { join_options: {media: :direct} } }
 
                 it "should rejoin with the same parameters" do
-                  other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
 
                   dial = Dial::Dial.new to, options, call
                   dial.run subject
@@ -542,14 +542,14 @@ module Adhearsion
 
                   dial.split
 
-                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct)
+                  expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct)
                   dial.rejoin
                 end
               end
 
               context "when join options are passed to rejoin" do
                 it "should rejoin with those parameters" do
-                  other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
 
                   dial = Dial::Dial.new to, options, call
                   dial.run subject
@@ -558,7 +558,7 @@ module Adhearsion
 
                   dial.split
 
-                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct)
+                  expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct)
                   dial.rejoin nil, media: :direct
                 end
               end
@@ -568,9 +568,9 @@ module Adhearsion
                 let(:options) { { join_target: join_target } }
 
                 it "joins the calls to the specified target on answer" do
-                  call.should_receive(:join).once.with(join_target, {})
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(join_target)
-                  call.should_receive(:unjoin).once.ordered.with(join_target).and_return do
+                  expect(call).to receive(:join).once.with(join_target, {})
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(join_target)
+                  expect(call).to receive(:unjoin).once.ordered.with(join_target) do
                     call << Punchblock::Event::Unjoined.new(join_target)
                     other_mock_call << Punchblock::Event::Unjoined.new(join_target)
                   end
@@ -589,16 +589,16 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
                   dial.rejoin
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
 
@@ -606,7 +606,7 @@ module Adhearsion
                 let(:mixer) { SecureRandom.uuid }
 
                 it "should join all calls to the mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
@@ -625,20 +625,20 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
                   dial.rejoin mixer_name: mixer
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
 
                 it "#split should then unjoin calls from the mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
@@ -657,24 +657,24 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
                   dial.rejoin mixer_name: mixer
 
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
                     other_mock_call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
-                  call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                  expect(call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
                     call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
                   dial.split
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(10)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
             end
@@ -688,13 +688,13 @@ module Adhearsion
               let(:other_dial)  { Dial::Dial.new second_to, options, second_root_call }
 
               before do
-                second_root_call.stub write_command: true, id: second_root_call_id
-                OutboundCall.should_receive(:new).and_return second_other_mock_call
-                second_other_mock_call.should_receive(:join).once.with(second_root_call, {})
-                second_other_mock_call.should_receive(:dial).once.with(second_to, options)
-                second_root_call.should_receive(:answer).once
+                allow(second_root_call).to receive_messages write_command: true, id: second_root_call_id
+                expect(OutboundCall).to receive(:new).and_return second_other_mock_call
+                expect(second_other_mock_call).to receive(:join).once.with(second_root_call, {})
+                expect(second_other_mock_call).to receive(:dial).once.with(second_to, options)
+                expect(second_root_call).to receive(:answer).once
 
-                SecureRandom.stub uuid: mixer
+                allow(SecureRandom).to receive_messages uuid: mixer
 
                 dial.run subject
                 other_dial.run subject
@@ -704,20 +704,20 @@ module Adhearsion
               end
 
               it "should split calls, rejoin to a mixer, and rejoin other calls to mixer" do
-                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
-                second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_return do
+                expect(second_other_mock_call).to receive(:unjoin).once.ordered.with(second_root_call) do
                   second_root_call << Punchblock::Event::Unjoined.new(call_uri: second_other_mock_call.id)
                   second_other_mock_call << Punchblock::Event::Unjoined.new(call_uri: second_root_call.id)
                 end
 
-                call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                 dial.merge other_dial
 
@@ -732,31 +732,31 @@ module Adhearsion
                 second_root_call.async << mock_end
                 second_other_mock_call.async << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               context "when join options were specified originally" do
                 let(:options) { { join_options: {media: :direct} } }
 
                 it "should rejoin with default options" do
-                  other_mock_call.stub(:unjoin)
-                  second_other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
+                  allow(second_other_mock_call).to receive(:unjoin)
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                  second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                   dial.merge other_dial
                 end
               end
 
               it "should add the merged calls to the returned status" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
                 dial.merge other_dial
 
                 waiter_thread = Thread.new do
@@ -770,15 +770,15 @@ module Adhearsion
                 second_root_call.async << mock_end
                 second_other_mock_call.async << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
-                dial.status.calls.should include(second_root_call, second_other_mock_call)
+                expect(dial.status.result).to eq(:answer)
+                expect(dial.status.calls).to include(second_root_call, second_other_mock_call)
               end
 
               it "should not unblock until all joined calls end" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                 dial.merge other_dial
 
@@ -790,24 +790,24 @@ module Adhearsion
                 sleep 0.5
 
                 other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 second_other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 second_root_call << mock_end
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               it "should cleanup merged calls when the root call ends" do
                 [call, other_mock_call, second_root_call, second_other_mock_call].each do |c|
-                  c.stub join: true, unjoin: true
+                  allow(c).to receive_messages join: true, unjoin: true
                 end
                 [other_mock_call, second_root_call, second_other_mock_call].each do |c|
-                  c.should_receive(:hangup).once
+                  expect(c).to receive(:hangup).once
                 end
 
                 dial.merge other_dial
@@ -821,14 +821,14 @@ module Adhearsion
                 sleep 0.5
 
                 call << mock_end
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               it "should subsequently rejoin to a mixer" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                 dial.merge other_dial
 
@@ -840,10 +840,10 @@ module Adhearsion
                 sleep 0.5
 
                 other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 [call, second_root_call, second_other_mock_call].each do |call|
-                  call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                  expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
                     call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
                 end
@@ -851,7 +851,7 @@ module Adhearsion
                 dial.split
 
                 [call, second_root_call, second_other_mock_call].each do |call|
-                  call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                  expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
                     call << Punchblock::Event::Joined.new(mixer_name: mixer)
                   end
                 end
@@ -861,8 +861,8 @@ module Adhearsion
 
               describe "if splitting fails" do
                 it "should not add the merged calls to the returned status" do
-                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
-                  other_dial.should_receive(:split).and_raise StandardError
+                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
+                  expect(other_dial).to receive(:split).and_raise StandardError
                   expect { dial.merge other_dial }.to raise_error(StandardError)
 
                   waiter_thread = Thread.new do
@@ -876,17 +876,17 @@ module Adhearsion
                   second_root_call.async << mock_end
                   second_other_mock_call.async << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
-                  dial.status.calls.should_not include(second_root_call, second_other_mock_call)
+                  expect(dial.status.result).to eq(:answer)
+                  expect(dial.status.calls).not_to include(second_root_call, second_other_mock_call)
                 end
 
                 it "should unblock before all joined calls end" do
-                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
-                  other_dial.should_receive(:split).and_raise StandardError
+                  expect(other_dial).to receive(:split).and_raise StandardError
                   expect { dial.merge other_dial }.to raise_error(StandardError)
 
                   waiter_thread = Thread.new do
@@ -897,28 +897,28 @@ module Adhearsion
                   sleep 0.5
 
                   other_mock_call << mock_end
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   second_other_mock_call << mock_end
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   second_root_call << mock_end
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
 
                 it "should not cleanup merged calls when the root call ends" do
                   [call, other_mock_call, second_root_call, second_other_mock_call].each do |c|
-                    c.stub join: true, unjoin: true
+                    allow(c).to receive_messages join: true, unjoin: true
                   end
-                  other_mock_call.should_receive(:hangup).once
+                  expect(other_mock_call).to receive(:hangup).once
                   [second_root_call, second_other_mock_call].each do |c|
-                    c.should_receive(:hangup).never
+                    expect(c).to receive(:hangup).never
                   end
 
-                  other_dial.should_receive(:split).and_raise StandardError
+                  expect(other_dial).to receive(:split).and_raise StandardError
                   expect { dial.merge other_dial }.to raise_error(StandardError)
 
                   waiter_thread = Thread.new do
@@ -930,16 +930,16 @@ module Adhearsion
                   sleep 0.5
 
                   call << mock_end
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
 
               context "if a call hangs up" do
                 it "should still allow splitting and rejoining" do
-                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                   dial.merge other_dial
 
@@ -951,25 +951,25 @@ module Adhearsion
                   sleep 0.5
 
                   [call, second_root_call, second_other_mock_call].each do |call|
-                    call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                    expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
                       call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                     end
                   end
 
-                  other_mock_call.should_receive(:unjoin).and_raise Adhearsion::Call::Hangup
+                  expect(other_mock_call).to receive(:unjoin).and_raise Adhearsion::Call::Hangup
 
                   dial.split
 
                   other_mock_call << mock_end
-                  latch.wait(2).should be_false
+                  expect(latch.wait(2)).to be_falsey
 
                   [call, second_root_call, second_other_mock_call].each do |call|
-                    call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                    expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
                       call << Punchblock::Event::Joined.new(mixer_name: mixer)
                     end
                   end
 
-                  other_mock_call.should_receive(:join).and_raise Adhearsion::Call::ExpiredError
+                  expect(other_mock_call).to receive(:join).and_raise Adhearsion::Call::ExpiredError
 
                   dial.rejoin
                 end
@@ -977,14 +977,14 @@ module Adhearsion
 
               context "if the calls were not joined" do
                 it "should still join to mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
-                  second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  expect(second_other_mock_call).to receive(:unjoin).once.ordered.with(second_root_call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                  second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                   dial.merge other_dial
 
@@ -999,10 +999,10 @@ module Adhearsion
                   second_root_call.async << mock_end
                   second_other_mock_call.async << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
             end
@@ -1019,7 +1019,7 @@ module Adhearsion
           end
 
           it "should not make any outbound calls" do
-            OutboundCall.should_receive(:new).never
+            expect(OutboundCall).to receive(:new).never
             expect { subject.dial to, options }.to raise_error
           end
         end
@@ -1030,12 +1030,12 @@ module Adhearsion
           let(:second_other_options) { options }
 
           before do
-            OutboundCall.should_receive(:new).and_return other_mock_call, second_other_mock_call
+            expect(OutboundCall).to receive(:new).and_return other_mock_call, second_other_mock_call
 
-            other_mock_call.should_receive(:dial).once.with(to, other_options)
+            expect(other_mock_call).to receive(:dial).once.with(to, other_options)
 
-            second_other_mock_call.should_receive(:dial).once.with(second_to, second_other_options)
-            second_other_mock_call.should_receive(:join).never
+            expect(second_other_mock_call).to receive(:dial).once.with(second_to, second_other_options)
+            expect(second_other_mock_call).to receive(:join).never
           end
 
           def dial_in_thread
@@ -1047,50 +1047,50 @@ module Adhearsion
           end
 
           it "dials all parties and joins the first one to answer, hanging up the rest" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
-            second_other_mock_call.should_receive(:hangup).once.and_return do
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
+            expect(second_other_mock_call).to receive(:hangup).once do
               second_other_mock_call << mock_end
             end
 
             t = dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
 
             t.join
             status = t.value
-            status.should be_a Dial::DialStatus
-            status.should have(2).calls
-            status.calls.each { |c| c.should be_a OutboundCall }
+            expect(status).to be_a Dial::DialStatus
+            expect(status.calls.size).to eq(2)
+            status.calls.each { |c| expect(c).to be_a OutboundCall }
           end
 
           it "unblocks when the joined call unjoins, allowing it to proceed further" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
-            other_mock_call.should_receive(:hangup).once
-            second_other_mock_call.should_receive(:hangup).once.and_return do
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
+            expect(other_mock_call).to receive(:hangup).once
+            expect(second_other_mock_call).to receive(:hangup).once do
               second_other_mock_call << mock_end
             end
 
             t = dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
 
             t.join
             status = t.value
-            status.should be_a Dial::DialStatus
-            status.should have(2).calls
-            status.calls.each { |c| c.should be_a OutboundCall }
+            expect(status).to be_a Dial::DialStatus
+            expect(status.calls.size).to eq(2)
+            status.calls.each { |c| expect(c).to be_a OutboundCall }
           end
 
           describe "with options overrides" do
@@ -1154,11 +1154,11 @@ module Adhearsion
                 latch.countdown!
               end
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
               other_mock_call << mock_end
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
               second_other_mock_call << mock_end
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
               t.join
             end
           end
@@ -1172,19 +1172,19 @@ module Adhearsion
               other_mock_call << mock_end(:reject)
               second_other_mock_call << mock_end(:reject)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :no_answer
+              expect(status.result).to eq(:no_answer)
             end
           end
 
           context "when a call is answered and joined, and the other ends with an error" do
             it "has an overall dial status of :answer" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {})
-              second_other_mock_call.should_receive(:hangup).once.and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {})
+              expect(second_other_mock_call).to receive(:hangup).once do
                 second_other_mock_call << mock_end(:error)
               end
 
@@ -1195,11 +1195,11 @@ module Adhearsion
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
             end
           end
         end
@@ -1208,9 +1208,9 @@ module Adhearsion
           let(:timeout) { 3 }
 
           it "should abort the dial after the specified timeout" do
-            other_mock_call.should_receive(:dial).once
-            other_mock_call.should_receive(:hangup).once
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(other_mock_call).to receive(:dial).once
+            expect(other_mock_call).to receive(:hangup).once
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
 
             time = Time.now
 
@@ -1222,18 +1222,18 @@ module Adhearsion
 
             latch.wait
             time = Time.now - time
-            time.round.should be == timeout
+            expect(time.round).to eq(timeout)
             t.join
             status = t.value
-            status.result.should be == :timeout
+            expect(status.result).to eq(:timeout)
           end
 
           describe "if someone answers before the timeout elapses" do
             it "should not abort until the far end hangs up" do
-              other_mock_call.should_receive(:dial).once.with(to, hash_including(:timeout => timeout))
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {})
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once.with(to, hash_including(:timeout => timeout))
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {})
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
 
               time = Time.now
 
@@ -1243,20 +1243,20 @@ module Adhearsion
                 status
               end
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_end
 
-              latch.wait(0.1).should be_true
+              expect(latch.wait(0.1)).to be_truthy
               time = Time.now - time
-              time.to_i.should be > timeout
+              expect(time.to_i).to be > timeout
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
             end
           end
         end
@@ -1286,62 +1286,65 @@ module Adhearsion
             let(:options) { {:confirm => confirmation_controller, :confirm_metadata => {:foo => 'bar'}} }
 
             before do
-              other_mock_call.should_receive(:dial).once
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
             end
 
             it "should set the metadata on the controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
 
               dial_in_thread
 
-              latch.wait(0.1).should be_false
+              expect(latch.wait(0.1)).to be_falsey
 
               other_mock_call << mock_answered
 
-              confirmation_latch.wait(2).should be_true
-              latch.wait(2).should be_true
+              expect(confirmation_latch.wait(2)).to be_truthy
+              expect(latch.wait(2)).to be_truthy
 
-              other_mock_call[:foo].should == 'bar'
+              expect(other_mock_call[:foo]).to eq('bar')
             end
           end
 
           context "when an outbound call is answered" do
             before do
-              other_mock_call.should_receive(:dial).once
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
             end
 
             it "should execute the specified confirmation controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
 
               dial_in_thread
 
-              latch.wait(0.1).should be_false
+              expect(latch.wait(0.1)).to be_falsey
 
               other_mock_call << mock_answered
 
-              confirmation_latch.wait(2).should be_true
-              latch.wait(2).should be_true
+              expect(confirmation_latch.wait(2)).to be_truthy
+              expect(latch.wait(2)).to be_truthy
             end
 
             it "should join the calls if the call is still active after execution of the call controller" do
               other_mock_call['confirm'] = true
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
+              expect(other_mock_call).to receive(:hangup).once do
+                other_mock_call << mock_end
+              end
 
               t = dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               base_time = Time.local(2008, 9, 1, 12, 0, 0)
               Timecop.freeze base_time
@@ -1351,48 +1354,47 @@ module Adhearsion
               base_time = Time.local(2008, 9, 1, 12, 0, 42)
               Timecop.freeze base_time
               other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
-              other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(3)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 42.0
-              joined_status.result.should == :joined
+              expect(joined_status.duration).to eq(42.0)
+              expect(joined_status.result).to eq(:joined)
             end
 
             it "should not join the calls if the call is not active after execution of the call controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
-              call.should_receive(:answer).never
-              other_mock_call.should_receive(:join).never.with(call)
+              expect(call).to receive(:answer).never
+              expect(other_mock_call).to receive(:join).never.with(call)
 
               t = dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :unconfirmed
+              expect(status.result).to eq(:unconfirmed)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 0.0
-              joined_status.result.should == :unconfirmed
+              expect(joined_status.duration).to eq(0.0)
+              expect(joined_status.result).to eq(:unconfirmed)
             end
           end
 
           context "when multiple calls are made" do
             before do
-              OutboundCall.should_receive(:new).and_return other_mock_call, second_other_mock_call
+              expect(OutboundCall).to receive(:new).and_return other_mock_call, second_other_mock_call
             end
 
             def dial_in_thread
@@ -1406,41 +1408,41 @@ module Adhearsion
             context "when one answers" do
               it "should only execute the confirmation controller on the first call to answer, immediately hanging up all others" do
                 other_mock_call['confirm'] = true
-                call.should_receive(:answer).once
+                expect(call).to receive(:answer).once
 
-                other_mock_call.should_receive(:dial).once.with(to, from: nil)
-                other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+                expect(other_mock_call).to receive(:dial).once.with(to, from: nil)
+                expect(other_mock_call).to receive(:join).once.with(call, {}) do
                   call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                 end
-                other_mock_call.should_receive(:hangup).once.and_return do
+                expect(other_mock_call).to receive(:hangup).once do
                   other_mock_call << mock_end
                 end
 
-                second_other_mock_call.should_receive(:dial).once.with(second_to, from: nil)
-                second_other_mock_call.should_receive(:join).never
-                second_other_mock_call.should_receive(:execute_controller).never
-                second_other_mock_call.should_receive(:hangup).once.and_return do
+                expect(second_other_mock_call).to receive(:dial).once.with(second_to, from: nil)
+                expect(second_other_mock_call).to receive(:join).never
+                expect(second_other_mock_call).to receive(:execute_controller).never
+                expect(second_other_mock_call).to receive(:hangup).once do
                   second_other_mock_call << mock_end(:foo)
                 end
 
                 t = dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call << mock_answered
-                confirmation_latch.wait(2).should be_true
+                expect(confirmation_latch.wait(2)).to be_truthy
 
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 t.join
                 status = t.value
-                status.should be_a Dial::DialStatus
-                status.should have(2).calls
-                status.calls.each { |c| c.should be_a OutboundCall }
-                status.result.should be == :answer
+                expect(status).to be_a Dial::DialStatus
+                expect(status.calls.size).to eq(2)
+                status.calls.each { |c| expect(c).to be_a OutboundCall }
+                expect(status.result).to eq(:answer)
               end
             end
           end
@@ -1449,31 +1451,31 @@ module Adhearsion
 
       describe "#dial_and_confirm" do
         it "should dial the call to the correct endpoint and return a dial status object" do
-          OutboundCall.should_receive(:new).and_return other_mock_call
-          other_mock_call.should_receive(:dial).with(to, :from => 'foo').once
+          expect(OutboundCall).to receive(:new).and_return other_mock_call
+          expect(other_mock_call).to receive(:dial).with(to, :from => 'foo').once
           dial_thread = Thread.new do
             status = subject.dial_and_confirm(to, :from => 'foo')
 
-            status.should be_a Dial::DialStatus
+            expect(status).to be_a Dial::DialStatus
             joined_status = status.joins[status.calls.first]
-            joined_status.duration.should == 0.0
-            joined_status.result.should == :no_answer
+            expect(joined_status.duration).to eq(0.0)
+            expect(joined_status.result).to eq(:no_answer)
           end
           sleep 0.1
           other_mock_call << mock_end
-          dial_thread.join.should be_true
+          expect(dial_thread.join).to be_truthy
         end
 
         it "should default the caller ID to that of the original call" do
-          call.stub :from => 'sip:foo@bar.com'
-          OutboundCall.should_receive(:new).and_return other_mock_call
-          other_mock_call.should_receive(:dial).with(to, :from => 'sip:foo@bar.com').once
+          allow(call).to receive_messages :from => 'sip:foo@bar.com'
+          expect(OutboundCall).to receive(:new).and_return other_mock_call
+          expect(other_mock_call).to receive(:dial).with(to, :from => 'sip:foo@bar.com').once
           dial_thread = Thread.new do
             subject.dial_and_confirm to
           end
           sleep 0.1
           other_mock_call << mock_end
-          dial_thread.join.should be_true
+          expect(dial_thread.join).to be_truthy
         end
 
         let(:options) { { :foo => :bar } }
@@ -1488,61 +1490,61 @@ module Adhearsion
 
         describe "without a block" do
           before do
-            other_mock_call.should_receive(:dial).once.with(to, options)
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(other_mock_call).to receive(:dial).once.with(to, options)
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
           end
 
           it "blocks the original controller until the new call ends" do
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           it "unblocks the original controller if the original call ends" do
-            other_mock_call.should_receive(:hangup).once
+            expect(other_mock_call).to receive(:hangup).once
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           it "joins the new call to the existing one on answer" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
 
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           context "with a join target specified" do
             let(:options) { { join_target: {mixer_name: 'foobar'} } }
 
             it "joins the calls to the specified target on answer" do
-              call.should_receive(:answer).once
-              call.should_receive(:join).once.with({mixer_name: 'foobar'}, {})
-              other_mock_call.should_receive(:join).once.with({mixer_name: 'foobar'}, {})
+              expect(call).to receive(:answer).once
+              expect(call).to receive(:join).once.with({mixer_name: 'foobar'}, {})
+              expect(other_mock_call).to receive(:join).once.with({mixer_name: 'foobar'}, {})
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
           end
 
@@ -1551,18 +1553,18 @@ module Adhearsion
             let(:options) { { pre_join: ->(call) { foo.bar call } } }
 
             it "executes the callback prior to joining" do
-              foo.should_receive(:bar).once.with(other_mock_call).ordered
-              call.should_receive(:answer).once.ordered
-              other_mock_call.should_receive(:join).once.with(call, {}).ordered
+              expect(foo).to receive(:bar).once.with(other_mock_call).ordered
+              expect(call).to receive(:answer).once.ordered
+              expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
           end
 
@@ -1576,19 +1578,19 @@ module Adhearsion
             end
 
             it "plays the ringback asynchronously, terminating prior to joining" do
-              subject.should_receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
-              component.should_receive(:stop!).twice
-              call.should_receive(:answer).once.ordered
-              other_mock_call.should_receive(:join).once.with(call, {}).ordered
+              expect(subject).to receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
+              expect(component).to receive(:stop!).twice
+              expect(call).to receive(:answer).once.ordered
+              expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
               dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
             end
 
             context "as a callback" do
@@ -1596,51 +1598,51 @@ module Adhearsion
               let(:options) { { ringback: -> { foo.bar; component } } }
 
               it "calls the callback to start, and uses the return value of the callback to stop the ringback" do
-                foo.should_receive(:bar).once.ordered
-                component.should_receive(:stop!).twice
-                call.should_receive(:answer).once.ordered
-                other_mock_call.should_receive(:join).once.with(call, {}).ordered
+                expect(foo).to receive(:bar).once.ordered
+                expect(component).to receive(:stop!).twice
+                expect(call).to receive(:answer).once.ordered
+                expect(other_mock_call).to receive(:join).once.with(call, {}).ordered
 
                 dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call << mock_answered
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
               end
             end
 
             context "when the call is rejected" do
               it "terminates the ringback before returning" do
-                subject.should_receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
-                component.should_receive(:stop!).once
+                expect(subject).to receive(:play!).once.with(['file://tt-monkeys'], repeat_times: 0).and_return(component)
+                expect(component).to receive(:stop!).once
 
                 t = dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call << mock_end(:reject)
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
               end
             end
           end
 
           it "hangs up the new call when the root call ends" do
-            other_mock_call.should_receive(:hangup).once
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
+            expect(other_mock_call).to receive(:hangup).once
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
 
             dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
           end
 
           context "when the call is rejected" do
@@ -1651,11 +1653,11 @@ module Adhearsion
 
               other_mock_call << mock_end(:reject)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :no_answer
+              expect(status.result).to eq(:no_answer)
             end
           end
 
@@ -1667,22 +1669,22 @@ module Adhearsion
 
               other_mock_call << mock_end(:error)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :error
+              expect(status.result).to eq(:error)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 0.0
-              joined_status.result.should == :error
+              expect(joined_status.duration).to eq(0.0)
+              expect(joined_status.result).to eq(:error)
             end
           end
 
           context "when the call is answered and joined" do
             it "has an overall dial status of :answer" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
@@ -1694,23 +1696,23 @@ module Adhearsion
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.result.should == :joined
+              expect(joined_status.result).to eq(:joined)
             end
 
             it "records the duration of the join" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
-              other_mock_call.stub hangup: true
+              allow(other_mock_call).to receive_messages hangup: true
 
               t = dial_in_thread
 
@@ -1726,25 +1728,25 @@ module Adhearsion
               other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 37.0
+              expect(joined_status.duration).to eq(37.0)
             end
 
             context "when join options are specified" do
               let(:options) { { join_options: {media: :direct} } }
 
               it "joins the calls with those options" do
-                call.should_receive(:answer).once
-                other_mock_call.should_receive(:join).once.with(call, media: :direct).and_return do
+                expect(call).to receive(:answer).once
+                expect(other_mock_call).to receive(:join).once.with(call, media: :direct) do
                   call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                 end
-                other_mock_call.stub hangup: true
+                allow(other_mock_call).to receive_messages hangup: true
 
                 t = dial_in_thread
 
@@ -1755,7 +1757,7 @@ module Adhearsion
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 t.join
               end
@@ -1766,19 +1768,19 @@ module Adhearsion
             let(:join_target) { call }
 
             before do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(join_target, join_options).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(join_target, join_options) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
-              other_mock_call.stub(:unjoin).and_return do
+              allow(other_mock_call).to receive(:unjoin) do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
             end
 
             it "should unjoin the calls" do
-              other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+              expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
@@ -1798,10 +1800,10 @@ module Adhearsion
               dial.split
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
-              dial.status.result.should be == :answer
+              expect(dial.status.result).to eq(:answer)
             end
 
             it "should not unblock immediately" do
@@ -1819,14 +1821,14 @@ module Adhearsion
 
               dial.split
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
-              dial.status.result.should be == :answer
+              expect(dial.status.result).to eq(:answer)
             end
 
             it "should set end time" do
@@ -1853,13 +1855,13 @@ module Adhearsion
               Timecop.freeze base_time
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               waiter_thread.join
               status = dial.status
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 37.0
+              expect(joined_status.duration).to eq(37.0)
             end
 
             context "with new controllers specified" do
@@ -1894,32 +1896,32 @@ module Adhearsion
 
                 other_mock_call << mock_answered
 
-                should_receive(:callback).once.with(call)
-                should_receive(:callback).once.with(other_mock_call)
+                expect(self).to receive(:callback).once.with(call)
+                expect(self).to receive(:callback).once.with(other_mock_call)
 
                 dial.split main: main_split_controller, others: others_split_controller, main_callback: ->(call) { self.callback(call) }, others_callback: ->(call) { self.callback(call) }
 
-                latch.wait(2).should be_false
-                split_latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_falsey
+                expect(split_latch.wait(2)).to be_truthy
 
-                call['hit_split_controller'].should == main_split_controller
-                call['split_controller_metadata']['current_dial'].should be dial
+                expect(call['hit_split_controller']).to eq(main_split_controller)
+                expect(call['split_controller_metadata']['current_dial']).to be dial
 
-                other_mock_call['hit_split_controller'].should == others_split_controller
-                other_mock_call['split_controller_metadata']['current_dial'].should be dial
+                expect(other_mock_call['hit_split_controller']).to eq(others_split_controller)
+                expect(other_mock_call['split_controller_metadata']['current_dial']).to be dial
 
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
             end
 
             context "when rejoining" do
               it "should rejoin the calls" do
-                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
@@ -1938,7 +1940,7 @@ module Adhearsion
 
                 dial.split
 
-                other_mock_call.should_receive(:join).once.ordered.with(call, {}).and_return do
+                expect(other_mock_call).to receive(:join).once.ordered.with(call, {}) do
                   call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                 end
@@ -1946,17 +1948,17 @@ module Adhearsion
 
                 other_mock_call << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               context "when join options were set originally" do
                 let(:options) { { join_options: {media: :direct} } }
 
                 it "should rejoin with the same parameters" do
-                  other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
 
                   dial = Dial::ParallelConfirmationDial.new to, options, call
                   dial.run subject
@@ -1965,7 +1967,7 @@ module Adhearsion
 
                   dial.split
 
-                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct).and_return do
+                  expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct) do
                     call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                   end
@@ -1975,7 +1977,7 @@ module Adhearsion
 
               context "when join options are passed to rejoin" do
                 it "should rejoin with those parameters" do
-                  other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
 
                   dial = Dial::ParallelConfirmationDial.new to, options, call
                   dial.run subject
@@ -1984,7 +1986,7 @@ module Adhearsion
 
                   dial.split
 
-                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct).and_return do
+                  expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct) do
                     call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                   end
@@ -1997,9 +1999,9 @@ module Adhearsion
                 let(:options) { { join_target: join_target } }
 
                 it "joins the calls to the specified target on answer" do
-                  call.should_receive(:join).once.with(join_target, {})
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(join_target)
-                  call.should_receive(:unjoin).once.ordered.with(join_target).and_return do
+                  expect(call).to receive(:join).once.with(join_target, {})
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(join_target)
+                  expect(call).to receive(:unjoin).once.ordered.with(join_target) do
                     call << Punchblock::Event::Unjoined.new(join_target)
                     other_mock_call << Punchblock::Event::Unjoined.new(join_target)
                   end
@@ -2018,16 +2020,16 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
                   dial.rejoin
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
 
@@ -2035,7 +2037,7 @@ module Adhearsion
                 let(:mixer) { SecureRandom.uuid }
 
                 it "should join all calls to the mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
@@ -2054,20 +2056,20 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
                   dial.rejoin mixer_name: mixer
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
 
                 it "#split should then unjoin calls from the mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
@@ -2086,24 +2088,24 @@ module Adhearsion
 
                   dial.split
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
                   dial.rejoin mixer_name: mixer
 
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
                     other_mock_call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
-                  call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                  expect(call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
                     call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
                   dial.split
 
                   other_mock_call << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
             end
@@ -2117,13 +2119,13 @@ module Adhearsion
               let(:other_dial)  { Dial::ParallelConfirmationDial.new second_to, options, second_root_call }
 
               before do
-                second_root_call.stub write_command: true, id: second_root_call_id
-                OutboundCall.should_receive(:new).and_return second_other_mock_call
-                second_other_mock_call.should_receive(:join).once.with(second_root_call, {})
-                second_other_mock_call.should_receive(:dial).once.with(second_to, options)
-                second_root_call.should_receive(:answer).once
+                allow(second_root_call).to receive_messages write_command: true, id: second_root_call_id
+                expect(OutboundCall).to receive(:new).and_return second_other_mock_call
+                expect(second_other_mock_call).to receive(:join).once.with(second_root_call, {})
+                expect(second_other_mock_call).to receive(:dial).once.with(second_to, options)
+                expect(second_root_call).to receive(:answer).once
 
-                SecureRandom.stub uuid: mixer
+                allow(SecureRandom).to receive_messages uuid: mixer
 
                 dial.run subject
                 other_dial.run subject
@@ -2133,20 +2135,20 @@ module Adhearsion
               end
 
               it "should split calls, rejoin to a mixer, and rejoin other calls to mixer" do
-                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
-                second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_return do
+                expect(second_other_mock_call).to receive(:unjoin).once.ordered.with(second_root_call) do
                   second_root_call << Punchblock::Event::Unjoined.new(call_uri: second_other_mock_call.id)
                   second_other_mock_call << Punchblock::Event::Unjoined.new(call_uri: second_root_call.id)
                 end
 
-                call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                 dial.merge other_dial
 
@@ -2161,31 +2163,31 @@ module Adhearsion
                 second_root_call.async << mock_end
                 second_other_mock_call.async << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               context "when join options were specified originally" do
                 let(:options) { { join_options: {media: :direct} } }
 
                 it "should rejoin with default options" do
-                  other_mock_call.stub(:unjoin)
-                  second_other_mock_call.stub(:unjoin)
+                  allow(other_mock_call).to receive(:unjoin)
+                  allow(second_other_mock_call).to receive(:unjoin)
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                  second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                   dial.merge other_dial
                 end
               end
 
               it "should add the merged calls to the returned status" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
                 dial.merge other_dial
 
                 waiter_thread = Thread.new do
@@ -2199,15 +2201,15 @@ module Adhearsion
                 second_root_call.async << mock_end
                 second_other_mock_call.async << mock_end
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
-                dial.status.calls.should include(second_root_call, second_other_mock_call)
+                expect(dial.status.result).to eq(:answer)
+                expect(dial.status.calls).to include(second_root_call, second_other_mock_call)
               end
 
               it "should not unblock until all joined calls end" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                 dial.merge other_dial
 
@@ -2219,24 +2221,24 @@ module Adhearsion
                 sleep 0.5
 
                 other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 second_other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 second_root_call << mock_end
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               it "should cleanup merged calls when the root call ends" do
                 [call, other_mock_call, second_root_call, second_other_mock_call].each do |c|
-                  c.stub join: true, unjoin: true
+                  allow(c).to receive_messages join: true, unjoin: true
                 end
                 [other_mock_call, second_root_call, second_other_mock_call].each do |c|
-                  c.should_receive(:hangup).once
+                  expect(c).to receive(:hangup).once
                 end
 
                 dial.merge other_dial
@@ -2250,14 +2252,14 @@ module Adhearsion
                 sleep 0.5
 
                 call << mock_end
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
                 waiter_thread.join
-                dial.status.result.should be == :answer
+                expect(dial.status.result).to eq(:answer)
               end
 
               it "should subsequently rejoin to a mixer" do
-                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                 dial.merge other_dial
 
@@ -2269,10 +2271,10 @@ module Adhearsion
                 sleep 0.5
 
                 other_mock_call << mock_end
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 [call, second_root_call, second_other_mock_call].each do |call|
-                  call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                  expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
                     call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                   end
                 end
@@ -2280,7 +2282,7 @@ module Adhearsion
                 dial.split
 
                 [call, other_mock_call, second_root_call, second_other_mock_call].each do |call|
-                  call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                  expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
                     call << Punchblock::Event::Joined.new(mixer_name: mixer)
                   end
                 end
@@ -2290,7 +2292,7 @@ module Adhearsion
 
               context "if a call hangs up" do
                 it "should still allow splitting and rejoining" do
-                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| c.stub join: true, unjoin: true }
+                  [call, other_mock_call, second_root_call, second_other_mock_call].each { |c| allow(c).to receive_messages join: true, unjoin: true }
 
                   dial.merge other_dial
 
@@ -2302,25 +2304,25 @@ module Adhearsion
                   sleep 0.5
 
                   [call, second_root_call, second_other_mock_call].each do |call|
-                    call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                    expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
                       call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
                     end
                   end
 
-                  other_mock_call.should_receive(:unjoin).and_raise Adhearsion::Call::Hangup
+                  expect(other_mock_call).to receive(:unjoin).and_raise Adhearsion::Call::Hangup
 
                   dial.split
 
                   other_mock_call << mock_end
-                  latch.wait(2).should be_false
+                  expect(latch.wait(2)).to be_falsey
 
                   [call, second_root_call, second_other_mock_call].each do |call|
-                    call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                    expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
                       call << Punchblock::Event::Joined.new(mixer_name: mixer)
                     end
                   end
 
-                  other_mock_call.should_receive(:join).and_raise Adhearsion::Call::ExpiredError
+                  expect(other_mock_call).to receive(:join).and_raise Adhearsion::Call::ExpiredError
 
                   dial.rejoin
                 end
@@ -2328,14 +2330,14 @@ module Adhearsion
 
               context "if the calls were not joined" do
                 it "should still join to mixer" do
-                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
-                  second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  expect(second_other_mock_call).to receive(:unjoin).once.ordered.with(second_root_call).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
 
-                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
-                  second_root_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
-                  second_other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_root_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  expect(second_other_mock_call).to receive(:join).once.ordered.with({mixer_name: mixer}, {})
 
                   dial.merge other_dial
 
@@ -2350,10 +2352,10 @@ module Adhearsion
                   second_root_call.async << mock_end
                   second_other_mock_call.async << mock_end
 
-                  latch.wait(2).should be_true
+                  expect(latch.wait(2)).to be_truthy
 
                   waiter_thread.join
-                  dial.status.result.should be == :answer
+                  expect(dial.status.result).to eq(:answer)
                 end
               end
             end
@@ -2370,7 +2372,7 @@ module Adhearsion
           end
 
           it "should not make any outbound calls" do
-            OutboundCall.should_receive(:new).never
+            expect(OutboundCall).to receive(:new).never
             expect { subject.dial_and_confirm to, options }.to raise_error
           end
         end
@@ -2381,12 +2383,12 @@ module Adhearsion
           let(:second_other_options) { options }
 
           before do
-            OutboundCall.should_receive(:new).and_return other_mock_call, second_other_mock_call
+            expect(OutboundCall).to receive(:new).and_return other_mock_call, second_other_mock_call
 
-            other_mock_call.should_receive(:dial).once.with(to, other_options)
+            expect(other_mock_call).to receive(:dial).once.with(to, other_options)
 
-            second_other_mock_call.should_receive(:dial).once.with(second_to, second_other_options)
-            second_other_mock_call.should_receive(:join).never
+            expect(second_other_mock_call).to receive(:dial).once.with(second_to, second_other_options)
+            expect(second_other_mock_call).to receive(:join).never
           end
 
           def dial_in_thread
@@ -2398,50 +2400,50 @@ module Adhearsion
           end
 
           it "dials all parties and joins the first one to answer, hanging up the rest" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
-            second_other_mock_call.should_receive(:hangup).once.and_return do
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
+            expect(second_other_mock_call).to receive(:hangup).once do
               second_other_mock_call << mock_end
             end
 
             t = dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
 
             t.join
             status = t.value
-            status.should be_a Dial::DialStatus
-            status.should have(2).calls
-            status.calls.each { |c| c.should be_a OutboundCall }
+            expect(status).to be_a Dial::DialStatus
+            expect(status.calls.size).to eq(2)
+            status.calls.each { |c| expect(c).to be_a OutboundCall }
           end
 
           it "unblocks when the joined call unjoins, allowing it to proceed further" do
-            call.should_receive(:answer).once
-            other_mock_call.should_receive(:join).once.with(call, {})
-            other_mock_call.should_receive(:hangup).once
-            second_other_mock_call.should_receive(:hangup).once.and_return do
+            expect(call).to receive(:answer).once
+            expect(other_mock_call).to receive(:join).once.with(call, {})
+            expect(other_mock_call).to receive(:hangup).once
+            expect(second_other_mock_call).to receive(:hangup).once do
               second_other_mock_call << mock_end
             end
 
             t = dial_in_thread
 
-            latch.wait(2).should be_false
+            expect(latch.wait(2)).to be_falsey
 
             other_mock_call << mock_answered
             other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
 
             t.join
             status = t.value
-            status.should be_a Dial::DialStatus
-            status.should have(2).calls
-            status.calls.each { |c| c.should be_a OutboundCall }
+            expect(status).to be_a Dial::DialStatus
+            expect(status.calls.size).to eq(2)
+            status.calls.each { |c| expect(c).to be_a OutboundCall }
           end
 
           describe "with options overrides" do
@@ -2505,11 +2507,11 @@ module Adhearsion
                 latch.countdown!
               end
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
               other_mock_call << mock_end
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
               second_other_mock_call << mock_end
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
               t.join
             end
           end
@@ -2523,19 +2525,19 @@ module Adhearsion
               other_mock_call << mock_end(:reject)
               second_other_mock_call << mock_end(:reject)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :no_answer
+              expect(status.result).to eq(:no_answer)
             end
           end
 
           context "when a call is answered and joined, and the other ends with an error" do
             it "has an overall dial status of :answer" do
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {})
-              second_other_mock_call.should_receive(:hangup).once.and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {})
+              expect(second_other_mock_call).to receive(:hangup).once do
                 second_other_mock_call << mock_end(:error)
               end
 
@@ -2546,11 +2548,11 @@ module Adhearsion
               other_mock_call << mock_answered
               other_mock_call << mock_end
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
             end
           end
         end
@@ -2559,9 +2561,9 @@ module Adhearsion
           let(:timeout) { 3 }
 
           it "should abort the dial after the specified timeout" do
-            other_mock_call.should_receive(:dial).once
-            other_mock_call.should_receive(:hangup).once
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(other_mock_call).to receive(:dial).once
+            expect(other_mock_call).to receive(:hangup).once
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
 
             time = Time.now
 
@@ -2573,18 +2575,18 @@ module Adhearsion
 
             latch.wait
             time = Time.now - time
-            time.round.should be == timeout
+            expect(time.round).to eq(timeout)
             t.join
             status = t.value
-            status.result.should be == :timeout
+            expect(status.result).to eq(:timeout)
           end
 
           describe "if someone answers before the timeout elapses" do
             it "should not abort until the far end hangs up" do
-              other_mock_call.should_receive(:dial).once.with(to, hash_including(:timeout => timeout))
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {})
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once.with(to, hash_including(:timeout => timeout))
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {})
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
 
               time = Time.now
 
@@ -2594,20 +2596,20 @@ module Adhearsion
                 status
               end
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_end
 
-              latch.wait(0.1).should be_true
+              expect(latch.wait(0.1)).to be_truthy
               time = Time.now - time
-              time.to_i.should be > timeout
+              expect(time.to_i).to be > timeout
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
             end
           end
         end
@@ -2640,65 +2642,65 @@ module Adhearsion
             let(:options) { {:confirm => confirmation_controller, :confirm_metadata => {:foo => 'bar'}} }
 
             before do
-              other_mock_call.should_receive(:dial).once
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
             end
 
             it "should set the metadata on the controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
 
               dial_in_thread
 
-              latch.wait(0.1).should be_false
+              expect(latch.wait(0.1)).to be_falsey
 
               other_mock_call << mock_answered
 
-              confirmation_latch.wait(2).should be_true
-              latch.wait(2).should be_true
+              expect(confirmation_latch.wait(2)).to be_truthy
+              expect(latch.wait(2)).to be_truthy
 
-              other_mock_call[:foo].should == 'bar'
+              expect(other_mock_call[:foo]).to eq('bar')
             end
           end
 
           context "when an outbound call is answered" do
             before do
-              other_mock_call.should_receive(:dial).once
-              OutboundCall.should_receive(:new).and_return other_mock_call
+              expect(other_mock_call).to receive(:dial).once
+              expect(OutboundCall).to receive(:new).and_return other_mock_call
             end
 
             it "should execute the specified confirmation controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
 
               dial_in_thread
 
-              latch.wait(0.1).should be_false
+              expect(latch.wait(0.1)).to be_falsey
 
               other_mock_call << mock_answered
 
-              confirmation_latch.wait(2).should be_true
-              latch.wait(2).should be_true
+              expect(confirmation_latch.wait(2)).to be_truthy
+              expect(latch.wait(2)).to be_truthy
             end
 
             it "should join the calls if the call is still active after execution of the call controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = true
-              call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+              expect(call).to receive(:answer).once
+              expect(other_mock_call).to receive(:join).once.with(call, {}) do
                 call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
               end
 
               t = dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               base_time = Time.local(2008, 9, 1, 12, 0, 0)
               Timecop.freeze base_time
@@ -2709,40 +2711,40 @@ module Adhearsion
               Timecop.freeze base_time
               other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :answer
+              expect(status.result).to eq(:answer)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 42.0
-              joined_status.result.should == :joined
+              expect(joined_status.duration).to eq(42.0)
+              expect(joined_status.result).to eq(:joined)
             end
 
             it "should not join the calls if the call is not active after execution of the call controller" do
-              other_mock_call.should_receive(:hangup).once.and_return do
+              expect(other_mock_call).to receive(:hangup).once do
                 other_mock_call << mock_end
               end
               other_mock_call['confirm'] = false
-              call.should_receive(:answer).never
-              other_mock_call.should_receive(:join).never.with(call)
+              expect(call).to receive(:answer).never
+              expect(other_mock_call).to receive(:join).never.with(call)
 
               t = dial_in_thread
 
-              latch.wait(2).should be_false
+              expect(latch.wait(2)).to be_falsey
 
               other_mock_call << mock_answered
 
-              latch.wait(2).should be_true
+              expect(latch.wait(2)).to be_truthy
 
               t.join
               status = t.value
-              status.result.should be == :unconfirmed
+              expect(status.result).to eq(:unconfirmed)
 
               joined_status = status.joins[status.calls.first]
-              joined_status.duration.should == 0.0
-              joined_status.result.should == :unconfirmed
+              expect(joined_status.duration).to eq(0.0)
+              expect(joined_status.result).to eq(:unconfirmed)
             end
           end
 
@@ -2760,7 +2762,7 @@ module Adhearsion
             let(:options) { {confirm: confirmation_controller, confirm_metadata: {'foo' => 'bar'}, apology: apology_controller} }
 
             before do
-              OutboundCall.should_receive(:new).and_return other_mock_call, second_other_mock_call
+              expect(OutboundCall).to receive(:new).and_return other_mock_call, second_other_mock_call
             end
 
             def dial_in_thread
@@ -2778,48 +2780,48 @@ module Adhearsion
                 second_other_mock_call['confirm'] = true
                 second_other_mock_call['confirmation_delay'] = 1.3
 
-                call.should_receive(:answer).once
+                expect(call).to receive(:answer).once
 
-                other_mock_call.should_receive(:dial).once.with(to, from: nil)
-                other_mock_call.should_receive(:join).once.with(call, {}).and_return do
+                expect(other_mock_call).to receive(:dial).once.with(to, from: nil)
+                expect(other_mock_call).to receive(:join).once.with(call, {}) do
                   call << Punchblock::Event::Joined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Joined.new(call_uri: call.id)
                 end
-                other_mock_call.should_receive(:hangup).once.and_return do
+                expect(other_mock_call).to receive(:hangup).once do
                   other_mock_call.async.deliver_message mock_end
                 end
 
-                second_other_mock_call.should_receive(:dial).once.with(second_to, from: nil)
-                second_other_mock_call.should_receive(:join).never
-                second_other_mock_call.should_receive(:hangup).once.and_return do
+                expect(second_other_mock_call).to receive(:dial).once.with(second_to, from: nil)
+                expect(second_other_mock_call).to receive(:join).never
+                expect(second_other_mock_call).to receive(:hangup).once do
                   second_other_mock_call.async.deliver_message mock_end
                 end
 
                 t = dial_in_thread
 
-                latch.wait(2).should be_false
+                expect(latch.wait(2)).to be_falsey
 
                 other_mock_call.async.deliver_message mock_answered
                 second_other_mock_call.async.deliver_message mock_answered
-                confirmation_latch.wait(2).should be_true
+                expect(confirmation_latch.wait(2)).to be_truthy
 
                 sleep 2
 
                 other_mock_call.async.deliver_message Punchblock::Event::Unjoined.new(call_uri: call.id)
 
-                latch.wait(2).should be_true
+                expect(latch.wait(2)).to be_truthy
 
-                second_other_mock_call['apology_done'].should be_true
-                second_other_mock_call['apology_metadata'].should == {'foo' => 'bar'}
+                expect(second_other_mock_call['apology_done']).to be_truthy
+                expect(second_other_mock_call['apology_metadata']).to eq({'foo' => 'bar'})
 
                 t.join
                 status = t.value
-                status.should be_a Dial::DialStatus
-                status.should have(2).calls
-                status.calls.each { |c| c.should be_a OutboundCall }
-                status.result.should be == :answer
-                status.joins[other_mock_call].result.should == :joined
-                status.joins[second_other_mock_call].result.should == :lost_confirmation
+                expect(status).to be_a Dial::DialStatus
+                expect(status.calls.size).to eq(2)
+                status.calls.each { |c| expect(c).to be_a OutboundCall }
+                expect(status.result).to eq(:answer)
+                expect(status.joins[other_mock_call].result).to eq(:joined)
+                expect(status.joins[second_other_mock_call].result).to eq(:lost_confirmation)
               end
             end
           end
@@ -2831,7 +2833,7 @@ module Adhearsion
 
         describe "#prep_calls" do
           it "yields all calls to the passed block" do
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
 
             gathered_calls = []
             subject.prep_calls { |call| gathered_calls << call }
@@ -2842,11 +2844,11 @@ module Adhearsion
 
         context "#skip_cleanup" do
           it "allows the new call to continue after the root call ends" do
-            OutboundCall.should_receive(:new).and_return other_mock_call
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
 
-            call.stub answer: true
-            other_mock_call.stub dial: true, join: true
-            other_mock_call.should_receive(:hangup).never
+            allow(call).to receive_messages answer: true
+            allow(other_mock_call).to receive_messages dial: true, join: true
+            expect(other_mock_call).to receive(:hangup).never
 
             subject.run double('controller')
 
@@ -2861,7 +2863,37 @@ module Adhearsion
             other_mock_call << mock_answered
             call << mock_end
 
-            latch.wait(2).should be_true
+            expect(latch.wait(2)).to be_truthy
+          end
+        end
+
+        describe "#cleanup_calls" do
+          let(:dial) { Dial::Dial.new to, dial_options, call }
+
+          before do
+            allow(other_mock_call).to receive_messages dial: true
+            expect(OutboundCall).to receive(:new).and_return other_mock_call
+          end
+
+          context "when a Cleanup Controller is specified" do
+            let(:cleanup_controller) do
+              Class.new(Adhearsion::CallController) do
+                def run
+                  logger.info "Cleaning up..."
+                end
+              end
+            end
+            let(:dial_options) { {cleanup: cleanup_controller} }
+
+            it "invokes the Cleanup Controller on each active outbound call before terminating the call" do
+              expect(cleanup_controller).to receive(:new).with(other_mock_call, anything)
+              Thread.new do
+                dial.run double(Adhearsion::CallController)
+                dial.cleanup_calls
+                latch.countdown!
+              end
+              expect(latch.wait(2)).to be_truthy
+            end
           end
         end
       end