adhearsion 2.4.0 → 2.5.0

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -19,6 +19,8 @@ module Adhearsion
 
       let(:latch) { CountDownLatch.new 1 }
 
+      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
@@ -96,7 +98,7 @@ module Adhearsion
 
           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)
+            other_mock_call.should_receive(:join).once.with(call, {})
 
             dial_in_thread
 
@@ -108,9 +110,110 @@ module Adhearsion
             latch.wait(1).should be_true
           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'}, {})
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+          end
+
+          context "with a pre-join callback specified" do
+            let(:foo) { double }
+            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
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+          end
+
+          context "with ringback specified" do
+            let(:component) { Punchblock::Component::Output.new }
+            let(:options) { { ringback: ['file://tt-monkeys'] } }
+
+            before do
+              component.request!
+              component.execute!
+            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
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+
+            context "as a callback" do
+              let(:foo) { double }
+              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
+
+                dial_in_thread
+
+                latch.wait(1).should be_false
+
+                other_mock_call << mock_answered
+                other_mock_call << mock_end
+
+                latch.wait(1).should be_true
+              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
+
+                t = dial_in_thread
+
+                latch.wait(1).should be_false
+
+                other_mock_call << mock_end(:reject)
+
+                latch.wait(1).should be_true
+              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(:join).once.with(call, {})
             other_mock_call.should_receive(:hangup).once
 
             dial_in_thread
@@ -162,7 +265,7 @@ module Adhearsion
           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)
+              other_mock_call.should_receive(:join).once.with(call, {})
 
               t = dial_in_thread
 
@@ -183,7 +286,7 @@ module Adhearsion
 
             it "records the duration of the join" do
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
+              other_mock_call.should_receive(:join).once.with(call, {})
               other_mock_call.stub hangup: true
 
               t = dial_in_thread
@@ -208,26 +311,51 @@ module Adhearsion
               joined_status = status.joins[status.calls.first]
               joined_status.duration.should == 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
+
+                t = dial_in_thread
+
+                sleep 0.5
+
+                other_mock_call << mock_answered
+
+                other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
+                other_mock_call << mock_end
+
+                latch.wait(1).should be_true
+
+                t.join
+              end
+            end
           end
 
           context "when a dial is split" do
+            let(:join_target) { call }
+
             before do
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
-              call.stub(:unjoin).and_return do
+              other_mock_call.should_receive(:join).once.with(join_target, join_options)
+              other_mock_call.stub(:unjoin).and_return 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
-              call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+              other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
 
               dial = Dial::Dial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -249,7 +377,7 @@ module Adhearsion
 
             it "should not unblock immediately" do
               dial = Dial::Dial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -274,7 +402,7 @@ module Adhearsion
 
             it "should set end time" do
               dial = Dial::Dial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -326,7 +454,7 @@ module Adhearsion
 
               it "should execute the :main controller on the originating call and :others on the outbound calls" do
                 dial = Dial::Dial.new to, options, call
-                dial.run
+                dial.run subject
 
                 waiter_thread = Thread.new do
                   dial.await_completion
@@ -362,13 +490,13 @@ module Adhearsion
 
             context "when rejoining" do
               it "should rejoin the calls" do
-                call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
 
                 dial = Dial::Dial.new to, options, call
-                dial.run
+                dial.run subject
 
                 waiter_thread = Thread.new do
                   dial.await_completion
@@ -381,7 +509,7 @@ module Adhearsion
 
                 dial.split
 
-                other_mock_call.should_receive(:join).once.ordered.with(call)
+                other_mock_call.should_receive(:join).once.ordered.with(call, {})
                 dial.rejoin
 
                 other_mock_call << mock_end
@@ -392,17 +520,122 @@ module Adhearsion
                 dial.status.result.should be == :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)
+
+                  dial = Dial::Dial.new to, options, call
+                  dial.run subject
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  other_mock_call.should_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)
+
+                  dial = Dial::Dial.new to, options, call
+                  dial.run subject
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct)
+                  dial.rejoin nil, media: :direct
+                end
+              end
+
+              context "when a join target was originally specified" do
+                let(:join_target) { {mixer_name: 'foobar'} }
+                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
+                    call << Punchblock::Event::Unjoined.new(join_target)
+                    other_mock_call << Punchblock::Event::Unjoined.new(join_target)
+                  end
+
+                  dial = Dial::Dial.new to, options, call
+                  dial.run subject
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  dial.rejoin
+
+                  other_mock_call << mock_end
+
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :answer
+                end
+              end
+
               context "to a specified mixer" do
                 let(:mixer) { SecureRandom.uuid }
 
                 it "should join all calls to the mixer" do
-                  call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
+                    call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
+                    other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
+                  end
+
+                  dial = Dial::Dial.new to, options, call
+                  dial.run subject
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  dial.rejoin mixer_name: mixer
+
+                  other_mock_call << mock_end
+
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :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
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
 
                   dial = Dial::Dial.new to, options, call
-                  dial.run
+                  dial.run subject
 
                   waiter_thread = Thread.new do
                     dial.await_completion
@@ -415,10 +648,18 @@ 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)
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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
+                    other_mock_call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                  call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                    call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                  dial.split
+
                   other_mock_call << mock_end
 
                   latch.wait(1).should be_true
@@ -440,34 +681,34 @@ module Adhearsion
               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(: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
 
                 SecureRandom.stub uuid: mixer
 
-                dial.run
-                other_dial.run
+                dial.run subject
+                other_dial.run subject
 
                 other_mock_call << mock_answered
                 second_other_mock_call << mock_answered
               end
 
               it "should split calls, rejoin to a mixer, and rejoin other calls to mixer" do
-                call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return 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_root_call.should_receive(:unjoin).once.ordered.with(second_other_mock_call.id).and_return do
+                second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_return 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)
+                call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                other_mock_call.should_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)
+                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}, {})
 
                 dial.merge other_dial
 
@@ -488,6 +729,23 @@ module Adhearsion
                 dial.status.result.should be == :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)
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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}, {})
+
+                  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 }
                 dial.merge other_dial
@@ -560,16 +818,164 @@ module Adhearsion
                 dial.status.result.should be == :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 }
+
+                dial.merge other_dial
+
+                waiter_thread = Thread.new do
+                  dial.await_completion
+                  latch.countdown!
+                end
+
+                sleep 0.5
+
+                other_mock_call << mock_end
+                latch.wait(1).should be_false
+
+                [call, second_root_call, second_other_mock_call].each do |call|
+                  call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                    call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                end
+
+                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
+                    call << Punchblock::Event::Joined.new(mixer_name: mixer)
+                  end
+                end
+
+                dial.rejoin
+              end
+
+              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
+                  expect { dial.merge other_dial }.to raise_error(StandardError)
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call.async << mock_end
+                  second_root_call.async << mock_end
+                  second_other_mock_call.async << mock_end
+
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :answer
+                  dial.status.calls.should_not 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 }
+
+                  other_dial.should_receive(:split).and_raise StandardError
+                  expect { dial.merge other_dial }.to raise_error(StandardError)
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call << mock_end
+                  latch.wait(1).should be_true
+
+                  second_other_mock_call << mock_end
+                  latch.wait(1).should be_true
+
+                  second_root_call << mock_end
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :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
+                  end
+                  other_mock_call.should_receive(:hangup).once
+                  [second_root_call, second_other_mock_call].each do |c|
+                    c.should_receive(:hangup).never
+                  end
+
+                  other_dial.should_receive(:split).and_raise StandardError
+                  expect { dial.merge other_dial }.to raise_error(StandardError)
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    dial.cleanup_calls
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  call << mock_end
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :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 }
+
+                  dial.merge other_dial
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  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
+                      call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                    end
+                  end
+
+                  other_mock_call.should_receive(:unjoin).and_raise Adhearsion::Call::Hangup
+
+                  dial.split
+
+                  other_mock_call << mock_end
+                  latch.wait(1).should be_false
+
+                  [call, second_root_call, second_other_mock_call].each do |call|
+                    call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                      call << Punchblock::Event::Joined.new(mixer_name: mixer)
+                    end
+                  end
+
+                  other_mock_call.should_receive(:join).and_raise Adhearsion::Call::ExpiredError
+
+                  dial.rejoin
+                end
+              end
+
               context "if the calls were not joined" do
                 it "should still join to mixer" do
-                  call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
-                  second_root_call.should_receive(:unjoin).once.ordered.with(second_other_mock_call.id).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  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)
 
-                  call.should_receive(:join).once.ordered.with(mixer_name: mixer)
-                  other_mock_call.should_receive(:join).once.ordered.with(mixer_name: mixer)
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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)
+                  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}, {})
 
                   dial.merge other_dial
 
@@ -633,7 +1039,7 @@ module Adhearsion
 
           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)
+            other_mock_call.should_receive(:join).once.with(call, {})
             second_other_mock_call.should_receive(:hangup).once.and_return do
               second_other_mock_call << mock_end
             end
@@ -656,7 +1062,7 @@ module Adhearsion
 
           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(:join).once.with(call, {})
             other_mock_call.should_receive(:hangup).once
             second_other_mock_call.should_receive(:hangup).once.and_return do
               second_other_mock_call << mock_end
@@ -768,7 +1174,7 @@ module Adhearsion
           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)
+              other_mock_call.should_receive(:join).once.with(call, {})
               second_other_mock_call.should_receive(:hangup).once.and_return do
                 second_other_mock_call << mock_end(:error)
               end
@@ -817,7 +1223,7 @@ module Adhearsion
             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)
+              other_mock_call.should_receive(:join).once.with(call, {})
               OutboundCall.should_receive(:new).and_return other_mock_call
 
               time = Time.now
@@ -920,7 +1326,7 @@ module Adhearsion
               other_mock_call.should_receive(:hangup).once
               other_mock_call['confirm'] = true
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
+              other_mock_call.should_receive(:join).once.with(call, {})
 
               t = dial_in_thread
 
@@ -992,7 +1398,7 @@ module Adhearsion
                 call.should_receive(:answer).once
 
                 other_mock_call.should_receive(:dial).once.with(to, from: nil)
-                other_mock_call.should_receive(:join).once.with(call)
+                other_mock_call.should_receive(:join).once.with(call, {})
                 other_mock_call.should_receive(:hangup).once.and_return do
                   other_mock_call << mock_end
                 end
@@ -1095,7 +1501,7 @@ module Adhearsion
 
           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)
+            other_mock_call.should_receive(:join).once.with(call, {})
 
             dial_in_thread
 
@@ -1107,10 +1513,111 @@ module Adhearsion
             latch.wait(1).should be_true
           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'}, {})
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+          end
+
+          context "with a pre-join callback specified" do
+            let(:foo) { double }
+            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
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+          end
+
+          context "with ringback specified" do
+            let(:component) { Punchblock::Component::Output.new }
+            let(:options) { { ringback: ['file://tt-monkeys'] } }
+
+            before do
+              component.request!
+              component.execute!
+            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
+
+              dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+              other_mock_call << mock_end
+
+              latch.wait(1).should be_true
+            end
+
+            context "as a callback" do
+              let(:foo) { double }
+              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
+
+                dial_in_thread
+
+                latch.wait(1).should be_false
+
+                other_mock_call << mock_answered
+                other_mock_call << mock_end
+
+                latch.wait(1).should be_true
+              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
+
+                t = dial_in_thread
+
+                latch.wait(1).should be_false
+
+                other_mock_call << mock_end(:reject)
+
+                latch.wait(1).should be_true
+              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)
+            other_mock_call.should_receive(:join).once.with(call, {})
 
             dial_in_thread
 
@@ -1161,7 +1668,7 @@ module Adhearsion
           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)
+              other_mock_call.should_receive(:join).once.with(call, {})
 
               t = dial_in_thread
 
@@ -1182,7 +1689,7 @@ module Adhearsion
 
             it "records the duration of the join" do
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
+              other_mock_call.should_receive(:join).once.with(call, {})
               other_mock_call.stub hangup: true
 
               t = dial_in_thread
@@ -1207,26 +1714,51 @@ module Adhearsion
               joined_status = status.joins[status.calls.first]
               joined_status.duration.should == 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
+
+                t = dial_in_thread
+
+                sleep 0.5
+
+                other_mock_call << mock_answered
+
+                other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
+                other_mock_call << mock_end
+
+                latch.wait(1).should be_true
+
+                t.join
+              end
+            end
           end
 
           context "when a dial is split" do
+            let(:join_target) { call }
+
             before do
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
-              call.stub(:unjoin).and_return do
+              other_mock_call.should_receive(:join).once.with(join_target, join_options)
+              other_mock_call.stub(:unjoin).and_return 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
-              call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+              other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
                 call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                 other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
               end
 
               dial = Dial::ParallelConfirmationDial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -1248,7 +1780,7 @@ module Adhearsion
 
             it "should not unblock immediately" do
               dial = Dial::ParallelConfirmationDial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -1273,7 +1805,7 @@ module Adhearsion
 
             it "should set end time" do
               dial = Dial::ParallelConfirmationDial.new to, options, call
-              dial.run
+              dial.run subject
 
               waiter_thread = Thread.new do
                 dial.await_completion
@@ -1325,7 +1857,7 @@ module Adhearsion
 
               it "should execute the :main controller on the originating call and :others on the outbound calls" do
                 dial = Dial::ParallelConfirmationDial.new to, options, call
-                dial.run
+                dial.run subject
 
                 waiter_thread = Thread.new do
                   dial.await_completion
@@ -1361,13 +1893,13 @@ module Adhearsion
 
             context "when rejoining" do
               it "should rejoin the calls" do
-                call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
                   call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                   other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                 end
 
                 dial = Dial::ParallelConfirmationDial.new to, options, call
-                dial.run
+                dial.run subject
 
                 waiter_thread = Thread.new do
                   dial.await_completion
@@ -1380,7 +1912,7 @@ module Adhearsion
 
                 dial.split
 
-                other_mock_call.should_receive(:join).once.ordered.with(call)
+                other_mock_call.should_receive(:join).once.ordered.with(call, {})
                 dial.rejoin
 
                 other_mock_call << mock_end
@@ -1391,17 +1923,90 @@ module Adhearsion
                 dial.status.result.should be == :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)
+
+                  dial = Dial::ParallelConfirmationDial.new to, options, call
+                  dial.run subject
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  other_mock_call.should_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)
+
+                  dial = Dial::ParallelConfirmationDial.new to, options, call
+                  dial.run subject
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  other_mock_call.should_receive(:join).once.ordered.with(call, media: :direct)
+                  dial.rejoin nil, media: :direct
+                end
+              end
+
+              context "when a join target was originally specified" do
+                let(:join_target) { {mixer_name: 'foobar'} }
+                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
+                    call << Punchblock::Event::Unjoined.new(join_target)
+                    other_mock_call << Punchblock::Event::Unjoined.new(join_target)
+                  end
+
+                  dial = Dial::ParallelConfirmationDial.new to, options, call
+                  dial.run subject
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: 'foobar'}, {})
+                  dial.rejoin
+
+                  other_mock_call << mock_end
+
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :answer
+                end
+              end
+
               context "to a specified mixer" do
                 let(:mixer) { SecureRandom.uuid }
 
                 it "should join all calls to the mixer" do
-                  call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                  other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return do
                     call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
                     other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
                   end
 
                   dial = Dial::ParallelConfirmationDial.new to, options, call
-                  dial.run
+                  dial.run subject
 
                   waiter_thread = Thread.new do
                     dial.await_completion
@@ -1414,8 +2019,8 @@ 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)
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
                   dial.rejoin mixer_name: mixer
 
                   other_mock_call << mock_end
@@ -1425,6 +2030,46 @@ module Adhearsion
                   waiter_thread.join
                   dial.status.result.should be == :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
+                    call << Punchblock::Event::Unjoined.new(call_uri: other_mock_call.id)
+                    other_mock_call << Punchblock::Event::Unjoined.new(call_uri: call.id)
+                  end
+
+                  dial = Dial::ParallelConfirmationDial.new to, options, call
+                  dial.run subject
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  sleep 0.5
+
+                  other_mock_call << mock_answered
+
+                  dial.split
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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
+                    other_mock_call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                  call.should_receive(:unjoin).once.ordered.with(mixer_name: mixer).and_return do
+                    call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                  dial.split
+
+                  other_mock_call << mock_end
+
+                  latch.wait(1).should be_true
+
+                  waiter_thread.join
+                  dial.status.result.should be == :answer
+                end
               end
             end
 
@@ -1439,34 +2084,34 @@ module Adhearsion
               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(: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
 
                 SecureRandom.stub uuid: mixer
 
-                dial.run
-                other_dial.run
+                dial.run subject
+                other_dial.run subject
 
                 other_mock_call << mock_answered
                 second_other_mock_call << mock_answered
               end
 
               it "should split calls, rejoin to a mixer, and rejoin other calls to mixer" do
-                call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_return do
+                other_mock_call.should_receive(:unjoin).once.ordered.with(call).and_return 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_root_call.should_receive(:unjoin).once.ordered.with(second_other_mock_call.id).and_return do
+                second_other_mock_call.should_receive(:unjoin).once.ordered.with(second_root_call).and_return 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)
+                call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                other_mock_call.should_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)
+                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}, {})
 
                 dial.merge other_dial
 
@@ -1487,6 +2132,23 @@ module Adhearsion
                 dial.status.result.should be == :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)
+
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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}, {})
+
+                  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 }
                 dial.merge other_dial
@@ -1559,16 +2221,86 @@ module Adhearsion
                 dial.status.result.should be == :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 }
+
+                dial.merge other_dial
+
+                waiter_thread = Thread.new do
+                  dial.await_completion
+                  latch.countdown!
+                end
+
+                sleep 0.5
+
+                other_mock_call << mock_end
+                latch.wait(1).should be_false
+
+                [call, second_root_call, second_other_mock_call].each do |call|
+                  call.should_receive(:unjoin).once.with(mixer_name: mixer).and_return do
+                    call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                  end
+                end
+
+                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
+                    call << Punchblock::Event::Joined.new(mixer_name: mixer)
+                  end
+                end
+
+                dial.rejoin
+              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 }
+
+                  dial.merge other_dial
+
+                  waiter_thread = Thread.new do
+                    dial.await_completion
+                    latch.countdown!
+                  end
+
+                  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
+                      call << Punchblock::Event::Unjoined.new(mixer_name: mixer)
+                    end
+                  end
+
+                  other_mock_call.should_receive(:unjoin).and_raise Adhearsion::Call::Hangup
+
+                  dial.split
+
+                  other_mock_call << mock_end
+                  latch.wait(1).should be_false
+
+                  [call, second_root_call, second_other_mock_call].each do |call|
+                    call.should_receive(:join).once.with({mixer_name: mixer}, {}).and_return do
+                      call << Punchblock::Event::Joined.new(mixer_name: mixer)
+                    end
+                  end
+
+                  other_mock_call.should_receive(:join).and_raise Adhearsion::Call::ExpiredError
+
+                  dial.rejoin
+                end
+              end
+
               context "if the calls were not joined" do
                 it "should still join to mixer" do
-                  call.should_receive(:unjoin).once.ordered.with(other_mock_call.id).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
-                  second_root_call.should_receive(:unjoin).once.ordered.with(second_other_mock_call.id).and_raise Punchblock::ProtocolError.new.setup(:service_unavailable)
+                  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)
 
-                  call.should_receive(:join).once.ordered.with(mixer_name: mixer)
-                  other_mock_call.should_receive(:join).once.ordered.with(mixer_name: mixer)
+                  call.should_receive(:join).once.ordered.with({mixer_name: mixer}, {})
+                  other_mock_call.should_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)
+                  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}, {})
 
                   dial.merge other_dial
 
@@ -1632,7 +2364,7 @@ module Adhearsion
 
           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)
+            other_mock_call.should_receive(:join).once.with(call, {})
             second_other_mock_call.should_receive(:hangup).once.and_return do
               second_other_mock_call << mock_end
             end
@@ -1655,7 +2387,7 @@ module Adhearsion
 
           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(:join).once.with(call, {})
             other_mock_call.should_receive(:hangup).once
             second_other_mock_call.should_receive(:hangup).once.and_return do
               second_other_mock_call << mock_end
@@ -1767,7 +2499,7 @@ module Adhearsion
           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)
+              other_mock_call.should_receive(:join).once.with(call, {})
               second_other_mock_call.should_receive(:hangup).once.and_return do
                 second_other_mock_call << mock_end(:error)
               end
@@ -1816,7 +2548,7 @@ module Adhearsion
             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)
+              other_mock_call.should_receive(:join).once.with(call, {})
               OutboundCall.should_receive(:new).and_return other_mock_call
 
               time = Time.now
@@ -1924,7 +2656,7 @@ module Adhearsion
               end
               other_mock_call['confirm'] = true
               call.should_receive(:answer).once
-              other_mock_call.should_receive(:join).once.with(call)
+              other_mock_call.should_receive(:join).once.with(call, {})
 
               t = dial_in_thread
 
@@ -2011,7 +2743,7 @@ module Adhearsion
                 call.should_receive(:answer).once
 
                 other_mock_call.should_receive(:dial).once.with(to, from: nil)
-                other_mock_call.should_receive(:join).once.with(call)
+                other_mock_call.should_receive(:join).once.with(call, {})
                 other_mock_call.should_receive(:hangup).once.and_return do
                   other_mock_call.async.deliver_message mock_end
                 end
@@ -2075,7 +2807,7 @@ module Adhearsion
             other_mock_call.stub dial: true, join: true
             other_mock_call.should_receive(:hangup).never
 
-            subject.run
+            subject.run double('controller')
 
             subject.skip_cleanup