adhearsion 2.0.1 → 2.1.0

data/spec/adhearsion/call_controller/record_spec.rb

@@ -14,16 +14,17 @@ module Adhearsion
             :max_duration => 5000
           }
         end
-        let(:component) { ::Punchblock::Component::Record.new options }
-        let(:response)  { ::Punchblock::Event::Complete.new }
+        let(:component) { Punchblock::Component::Record.new options }
+        let(:response)  { Punchblock::Event::Complete.new }
 
         describe "with :async => true and an :on_complete callback" do
           before do
             component
-            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
+            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
             expect_message_waiting_for_response component
             @rec = Queue.new
             subject.record(options.merge(async: true)) { |rec| @rec.push rec }
+            component.request!
             component.execute!
           end
 
@@ -39,7 +40,7 @@ module Adhearsion
           before do
             TestException = Class.new StandardError
             component
-            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with({}).and_return component
+            flexmock(Punchblock::Component::Record).should_receive(:new).once.with({}).and_return component
           end
 
           it "should pass the exception to the events system" do
@@ -62,7 +63,7 @@ module Adhearsion
         describe "with :async => false" do
           before do
             component
-            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
+            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
             expect_component_execution component
             @rec = Queue.new
             subject.record(options.merge(:async => false)) { |rec| @rec.push rec }
@@ -77,8 +78,50 @@ module Adhearsion
             end
           end
         end
-      end
 
+        describe "with :interruptible => false" do
+          let(:input_component) { Punchblock::Component::Input.new }
+          it "does not use an Input component" do
+            subject.should_receive(:execute_component_and_await_completion).once.with(component)
+            subject.should_receive(:write_and_await_response).never.with(input_component)
+            subject.record(options.merge(:async => false, :interruptible => false)) { |rec| @rec.push rec }
+          end
+        end
+
+        describe "with :interruptible => true" do
+          let(:input_component) { Punchblock::Component::Input.new }
+          it "stops the recording" do
+            flexmock(Punchblock::Event::Complete).new_instances.should_receive(:reason => flexmock(:name => :input))
+
+            def subject.write_and_await_response(input_component)
+              input_component.trigger_event_handler Punchblock::Event::Complete.new
+            end
+
+            complete_event = Punchblock::Event::Complete.new
+            flexmock(complete_event).should_receive(:reason => flexmock(:name => :input))
+            flexmock(Punchblock::Component::Input).new_instances do |input|
+              input.should_receive(:complete?).and_return(false)
+              input.should_receive(:complete_event).and_return(complete_event)
+            end
+            flexmock(Punchblock::Component::Record).new_instances.should_receive(:stop!)
+            subject.should_receive(:execute_component_and_await_completion).once.with(component)
+            subject.record(options.merge(:async => false, :interruptible => true)) { |rec| @rec.push rec }
+          end
+
+        end
+
+        describe "check for the return value" do
+          it "returns a Record component" do
+            component
+            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
+            expect_component_execution component
+            subject.record(options.merge(:async => false)).should be == component
+            component.request!
+            component.execute!
+          end
+        end
+
+      end
     end
   end
 end

data/spec/adhearsion/call_controller_spec.rb

@@ -201,7 +201,6 @@ module Adhearsion
 
     [ :answer,
       :reject,
-      :hangup,
       :mute,
       :unmute].each do |method_name|
       describe "##{method_name}" do
@@ -213,6 +212,14 @@ module Adhearsion
       end
     end
 
+    describe "#hangup" do
+      it "delegates to the call, blocking first until it is allowed to execute" do
+        flexmock(subject).should_receive(:block_until_resumed).once.ordered
+        flexmock(subject.call).should_receive(:hangup).once.ordered
+        lambda { subject.send :hangup }.should raise_error Call::Hangup
+      end
+    end
+
     describe "#join" do
       it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
         flexmock(subject).should_receive(:block_until_resumed).once.ordered
@@ -318,6 +325,7 @@ module Adhearsion
 
       before do
         expect_message_of_type_waiting_for_response component
+        component.request!
         component.execute!
         component.complete_event = response
       end
@@ -417,7 +425,7 @@ describe ExampleCallController do
   it "should execute the after_call callbacks after the call is hung up" do
     subject.should_receive(:join_to_conference).once.ordered
     subject.should_receive(:clean_up_models).twice.ordered
-    subject.should_receive(:foobar).once.ordered
+    subject.should_receive(:foobar).never
     subject.execute!
   end
 

data/spec/adhearsion/call_spec.rb

@@ -110,6 +110,132 @@ module Adhearsion
     describe "event handlers" do
       let(:response) { flexmock 'Response' }
 
+      describe "for joined events" do
+        context "joined to another call" do
+          let :event do
+            Punchblock::Event::Joined.new :call_id => 'foobar'
+          end
+
+          it "should trigger any on_joined callbacks set for the matching call ID" do
+            response.should_receive(:call).once.with(event)
+            subject.on_joined(:call_id => 'foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_joined callbacks for other call IDs" do
+            response.should_receive(:call).never
+            subject.on_joined(:call_id => 'barfoo') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_joined callbacks for mixers" do
+            response.should_receive(:call).never
+            subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
+            subject << event
+          end
+        end
+
+        context "joined to a mixer" do
+          let :event do
+            Punchblock::Event::Joined.new :mixer_name => 'foobar'
+          end
+
+          it "should trigger on_joined callbacks for the matching mixer name" do
+            response.should_receive(:call).once.with(event)
+            subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_joined callbacks for other mixer names" do
+            response.should_receive(:call).never
+            subject.on_joined(:mixer_name => 'barfoo') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger any on_joined callbacks set for calls" do
+            response.should_receive(:call).never
+            subject.on_joined(:call_id => 'foobar') { |event| response.call event }
+            subject << event
+          end
+        end
+      end
+
+      describe "for unjoined events" do
+        context "unjoined from another call" do
+          let :event do
+            Punchblock::Event::Unjoined.new :call_id => 'foobar'
+          end
+
+          it "should trigger any on_unjoined callbacks set for the matching call ID" do
+            response.should_receive(:call).once.with(event)
+            subject.on_unjoined(:call_id => 'foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should trigger any on_unjoined callbacks set for the matching call ID as a string" do
+            response.should_receive(:call).once.with(event)
+            subject.on_unjoined('foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should trigger any on_unjoined callbacks set for the matching call" do
+            response.should_receive(:call).once.with(event)
+            call = flexmock Call.new, :id => 'foobar'
+            subject.on_unjoined(call) { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_unjoined callbacks for other call IDs" do
+            response.should_receive(:call).never
+            subject.on_unjoined(:call_id => 'barfoo') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_unjoined callbacks for mixers" do
+            response.should_receive(:call).never
+            subject.on_joined(:mixer_name => 'foobar') { |event| response.call event }
+            subject << event
+          end
+        end
+
+        context "unjoined from a mixer" do
+          let :event do
+            Punchblock::Event::Unjoined.new :mixer_name => 'foobar'
+          end
+
+          it "should trigger on_unjoined callbacks for the matching mixer name" do
+            response.should_receive(:call).once.with(event)
+            subject.on_unjoined(:mixer_name => 'foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger on_unjoined callbacks for other mixer names" do
+            response.should_receive(:call).never
+            subject.on_unjoined(:mixer_name => 'barfoo') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger any on_unjoined callbacks set for calls" do
+            response.should_receive(:call).never
+            subject.on_unjoined(:call_id => 'foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger any on_unjoined callbacks set for the matching call ID as a string" do
+            response.should_receive(:call).never
+            subject.on_unjoined('foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger any on_unjoined callbacks set for the matching call" do
+            response.should_receive(:call).never
+            call = flexmock Call.new, :id => 'foobar'
+            subject.on_unjoined(call) { |event| response.call event }
+            subject << event
+          end
+        end
+      end
+
       describe "for end events" do
         let :event do
           Punchblock::Event::End.new.tap do |e|
@@ -621,6 +747,18 @@ module Adhearsion
           latch.wait(3).should be_true
         end
 
+        it "should use the passed block as a controller if none is specified" do
+          flexmock(CallController).should_receive(:exec).once.with CallController
+          subject.execute_controller nil, lambda { |call| latch.countdown! } do
+            foo
+          end
+          latch.wait(3).should be_true
+        end
+
+        it "should raise ArgumentError if both a controller and a block are passed" do
+          lambda { subject.execute_controller(mock_controller) { foo } }.should raise_error(ArgumentError)
+        end
+
         it "should add the controller thread to the important threads" do
           flexmock(CallController).should_receive(:exec)
           controller_thread = subject.execute_controller mock_controller, lambda { |call| latch.countdown! }

data/spec/adhearsion/calls_spec.rb

@@ -46,7 +46,7 @@ module Adhearsion
       context "by dead call object" do
         before do
           @call_id = deleted_call.id
-          deleted_call.terminate
+          deleted_call.kill
           deleted_call.should_not be_alive
           subject.remove_inactive_call deleted_call
         end

data/spec/adhearsion/outbound_call_spec.rb

@@ -22,24 +22,56 @@ module Adhearsion
 
       let(:mock_call) { OutboundCall.new }
 
-      it "should dial the call to the correct endpoint and return it" do
+      before do
         mock_call
         flexmock(OutboundCall).should_receive(:new).and_return mock_call
+      end
+
+      it "should dial the call to the correct endpoint and return it" do
         flexmock(mock_call.wrapped_object).should_receive(:dial).with(to, :from => 'foo').once
         OutboundCall.originate(to, :from => 'foo').should be mock_call
       end
 
       it "should run through the router when the call is answered" do
-        mock_call
-
-        flexmock(OutboundCall).should_receive(:new).and_return mock_call
         flexmock(mock_call.wrapped_object).should_receive(:dial).once
 
-        mock_dispatcher = flexmock 'dispatcher'
-        mock_dispatcher.should_receive(:call).once.with mock_call
-        flexmock(Adhearsion.router).should_receive(:handle).once.with(mock_call).and_return mock_dispatcher
+        flexmock(Adhearsion.router).should_receive(:handle).once.with(mock_call)
 
-        OutboundCall.originate(to).deliver_message Punchblock::Event::Answered.new
+        OutboundCall.originate(to) << Punchblock::Event::Answered.new
+      end
+
+      context "when a controller class is specified for the call" do
+        let(:controller)  { CallController }
+
+        it "should execute the controller on the call when it is answered" do
+          flexmock(mock_call).should_receive(:dial).once.with(to, {})
+          flexmock(mock_call).should_receive(:execute_controller).once.with controller, Proc
+          call = OutboundCall.originate to, :controller => controller
+          call << Punchblock::Event::Answered.new
+        end
+
+        it "should hangup the call after all controllers have executed" do
+          flexmock(mock_call).should_receive(:dial).once
+          flexmock(mock_call).should_receive(:hangup).once
+
+          call = OutboundCall.originate to, :controller => controller
+          call << Punchblock::Event::Answered.new
+          sleep 0.5
+        end
+      end
+
+      context "when given a block" do
+        it "should execute the block as a controller on the call when it is answered" do
+          flexmock(mock_call).should_receive(:dial).once.with(to, {})
+          flexmock(mock_call).should_receive(:execute_controller).once.with(CallController, Proc).and_return do |controller|
+            controller.block.call.should be == :foobar
+          end
+
+          call = OutboundCall.originate to do
+            :foobar
+          end
+          call << Punchblock::Event::Answered.new
+        end
       end
     end
 
@@ -104,6 +136,14 @@ module Adhearsion
         subject.dial to, :from => from
         Adhearsion.active_calls[call_id].should be subject
       end
+
+      it "should not modify the provided options" do
+        options = {:from => from}
+        original_options = Marshal.load(Marshal.dump(options))
+        options.should be == original_options
+        subject.dial to, options
+        options.should be == original_options
+      end
     end
 
     describe "basic control commands" do

data/spec/adhearsion/punchblock_plugin/initializer_spec.rb

@@ -20,6 +20,7 @@ module Adhearsion
           config.reconnect_attempts = 1.0/0.0
           config.reconnect_timer    = 5
           config.media_engine       = nil
+          config.default_voice      = nil
         end
       end
 
@@ -39,6 +40,7 @@ module Adhearsion
           config.reconnect_attempts = options[:reconnect_attempts] if options.has_key?(:reconnect_attempts)
           config.reconnect_timer    = options[:reconnect_timer] if options.has_key?(:reconnect_timer)
           config.media_engine       = options[:media_engine] if options.has_key?(:media_engine)
+          config.default_voice      = options[:default_voice] if options.has_key?(:default_voice)
         end
 
         Initializer.init
@@ -52,7 +54,7 @@ module Adhearsion
       end
 
       let(:call_id)   { rand }
-      let(:offer)     { ::Punchblock::Event::Offer.new.tap { |o| o.target_call_id = call_id } }
+      let(:offer)     { Punchblock::Event::Offer.new.tap { |o| o.target_call_id = call_id } }
       let(:mock_call) { flexmock('Call', :id => call_id).tap { |call| call.should_ignore_missing } }
 
       describe "starts the client with the default values" do
@@ -97,21 +99,25 @@ module Adhearsion
         it "should properly set the media_engine value" do
           subject.media_engine.should be == nil
         end
+
+        it "should properly set the default_voice value" do
+          subject.default_voice.should be == nil
+        end
       end
 
       it "starts the client with the correct resource" do
         username = "usera@127.0.0.1/hostname-1234"
 
-        flexmock(::Punchblock::Connection::XMPP).should_receive(:new).once.with(FlexMock.hsh :username => username).and_return do
+        flexmock(Punchblock::Connection::XMPP).should_receive(:new).once.with(FlexMock.hsh :username => username).and_return do
           flexmock 'Client', :event_handler= => true
         end
         initialize_punchblock
       end
 
       it "starts the client with any overridden settings" do
-        overrides = {:username => 'userb@127.0.0.1/foo', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com', :media_engine => :swift}
+        overrides = {:username => 'userb@127.0.0.1/foo', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com', :media_engine => :swift, :default_voice => :hal}
 
-        flexmock(::Punchblock::Connection::XMPP).should_receive(:new).once.with(overrides).and_return do
+        flexmock(Punchblock::Connection::XMPP).should_receive(:new).once.with(overrides).and_return do
           flexmock 'Client', :event_handler= => true
         end
         initialize_punchblock overrides
@@ -122,12 +128,12 @@ module Adhearsion
           reset_default_config
           mock_connection = flexmock :mock_connection
           mock_connection.should_receive(:register_event_handler).once
-          flexmock(::Punchblock::Client).should_receive(:new).once.and_return mock_connection
+          flexmock(Punchblock::Client).should_receive(:new).once.and_return mock_connection
           flexmock(mock_connection).should_receive(:run).once
           t = Thread.new { Initializer.init; Initializer.run }
           t.join 5
           t.status.should be == "sleep"
-          Events.trigger_immediately :punchblock, ::Punchblock::Connection::Connected.new
+          Events.trigger_immediately :punchblock, Punchblock::Connection::Connected.new
           t.join
         end
       end
@@ -150,42 +156,53 @@ module Adhearsion
         it 'should reset the Adhearsion process state to "booting"' do
           Adhearsion::Process.booted
           Adhearsion::Process.state_name.should be == :running
-          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
+          mock_client.should_receive(:run).and_raise Punchblock::DisconnectedError
           flexmock(Adhearsion::Process).should_receive(:reset).at_least.once
           Initializer.connect_to_server
         end
 
         it 'should retry the connection the specified number of times' do
           Initializer.config.reconnect_attempts = 3
-          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
+          mock_client.should_receive(:run).and_raise Punchblock::DisconnectedError
           Initializer.connect_to_server
           Initializer.attempts.should be == 3
         end
 
         it 'should preserve a Punchblock::ProtocolError exception and give up' do
-          mock_client.should_receive(:run).and_raise ::Punchblock::ProtocolError
-          expect { Initializer.connect_to_server }.should raise_error ::Punchblock::ProtocolError
+          mock_client.should_receive(:run).and_raise Punchblock::ProtocolError
+          expect { Initializer.connect_to_server }.to raise_error Punchblock::ProtocolError
         end
 
         it 'should not attempt to reconnect if Adhearsion is shutting down' do
           Adhearsion::Process.booted
           Adhearsion::Process.shutdown
-          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
-          Initializer.should_not raise_error ::Punchblock::DisconnectedError
+          mock_client.should_receive(:run).and_raise Punchblock::DisconnectedError
+          Initializer.should_not raise_error Punchblock::DisconnectedError
         end
       end
 
       describe 'using Asterisk' do
-        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com', :media_engine => :swift} }
+        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com', :media_engine => :swift, :default_voice => :hal} }
 
         it 'should start an Asterisk PB connection' do
-          flexmock(::Punchblock::Connection::Asterisk).should_receive(:new).once.with(overrides).and_return do
+          flexmock(Punchblock::Connection::Asterisk).should_receive(:new).once.with(overrides).and_return do
             flexmock 'Client', :event_handler= => true
           end
           initialize_punchblock overrides.merge(:platform => :asterisk)
         end
       end
 
+      describe 'using FreeSWITCH' do
+        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com', :media_engine => :swift, :default_voice => :hal} }
+
+        it 'should start an Asterisk PB connection' do
+          flexmock(Punchblock::Connection::Freeswitch).should_receive(:new).once.with(overrides).and_return do
+            flexmock 'Client', :event_handler= => true
+          end
+          initialize_punchblock overrides.merge(:platform => :freeswitch)
+        end
+      end
+
       it 'should place events from Punchblock into the event handler' do
         flexmock(Events.instance).should_receive(:trigger).once.with(:punchblock, offer)
         initialize_punchblock
@@ -210,17 +227,11 @@ module Adhearsion
         context "when when Adhearsion::Process is in :running" do
           let(:process_state) { :running }
 
-          it "should accept the call" do
-            mock_call.should_receive(:accept).once
-          end
-
-          it "should execute the dispatcher provided by the router" do
-            controller = Class.new
+          it "should dispatch via the router" do
             Adhearsion.router do
-              route 'foobar', controller
+              route 'foobar', Class.new
             end
-            first_route = Adhearsion.router.routes.first
-            flexmock(first_route.dispatcher).should_receive(:call).once.with mock_call
+            flexmock(Adhearsion.router).should_receive(:handle).once.with mock_call
           end
         end