adhearsion 2.0.1 → 2.1.0

data/lib/adhearsion/router.rb

@@ -4,7 +4,12 @@ module Adhearsion
   class Router
     extend ActiveSupport::Autoload
 
+    autoload :EventedRoute
+    autoload :OpenendedRoute
     autoload :Route
+    autoload :UnacceptingRoute
+
+    NoMatchError = Class.new Adhearsion::Error
 
     attr_reader :routes
 
@@ -24,9 +29,45 @@ module Adhearsion
     end
 
     def handle(call)
-      return unless route = match(call)
+      raise NoMatchError unless route = match(call)
       logger.info "Call #{call.id} selected route \"#{route.name}\" (#{route.target})"
-      route.dispatcher
+      route.dispatch call
+    rescue NoMatchError
+      logger.warn "Call #{call.id} could not find a matching route. Rejecting."
+      call.reject :error
+    end
+
+    module Filters
+      def evented(&block)
+        filtered_routes EventedRoute, &block
+      end
+
+      def unaccepting(&block)
+        filtered_routes UnacceptingRoute, &block
+      end
+
+      def openended(&block)
+        filtered_routes OpenendedRoute, &block
+      end
+
+      def filtered_routes(mixin, &block)
+        FilteredRouter.new(self, mixin).instance_exec(&block)
+      end
+    end
+
+    include Filters
+
+    class FilteredRouter < SimpleDelegator
+      include Filters
+
+      def initialize(delegate, mixin)
+        super delegate
+        @mixin = mixin
+      end
+
+      def route(*args, &block)
+        super.tap { |r| r.extend @mixin }
+      end
     end
   end
 end

data/lib/adhearsion/router/evented_route.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Adhearsion
+  class Router
+    module EventedRoute
+      def evented?
+        true
+      end
+
+      def dispatch(call, callback = nil)
+        target.call call, callback
+      end
+    end
+  end
+end

data/lib/adhearsion/router/openended_route.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Adhearsion
+  class Router
+    module OpenendedRoute
+      def openended?
+        true
+      end
+
+      def dispatch(call, callback = nil)
+        call[:ahn_prevent_hangup] = true
+        super
+      end
+    end
+  end
+end

data/lib/adhearsion/router/route.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'has_guarded_handlers'
+
 module Adhearsion
   class Router
     class Route
@@ -21,22 +23,38 @@ module Adhearsion
         !guarded? guards, call
       end
 
-      def dispatcher
-        @dispatcher ||= lambda do |call, callback = nil|
-          controller = if target.respond_to?(:call)
-            CallController.new call, &target
-          else
-            target.new call
-          end
+      def dispatch(call, callback = nil)
+        controller = if target.respond_to?(:call)
+          CallController.new call, &target
+        else
+          target.new call
+        end
 
-          call.execute_controller controller, lambda { |call_actor|
-            begin
+        call.accept if accepting?
+
+        call.execute_controller controller, lambda { |call_actor|
+          begin
+            if call_actor[:ahn_prevent_hangup]
+              logger.info "Call routing completed, keeping the call alive at controller/router request."
+            else
               call_actor.hangup
-            rescue Call::Hangup
             end
-            callback.call if callback
-          }
-        end
+          rescue Call::Hangup
+          end
+          callback.call if callback
+        }
+      end
+
+      def evented?
+        false
+      end
+
+      def accepting?
+        true
+      end
+
+      def openended?
+        false
       end
 
       def inspect

data/lib/adhearsion/router/unaccepting_route.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Adhearsion
+  class Router
+    module UnacceptingRoute
+      def accepting?
+        false
+      end
+    end
+  end
+end

data/lib/adhearsion/version.rb

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

data/pre-commit

@@ -1,2 +1,15 @@
-#!/bin/sh
+#!/bin/bash
 rake encodeify
+
+# avoid committing :focus on rspec examples
+focus=', :focus'
+result=$(git grep -n -a "$focus" -- */**/*_spec.rb)
+
+if [ "$result" != '' ]; then
+  echo ""
+  echo "Refusing to commit a :focus tag in specs: "
+  echo ""
+  echo $result
+  echo ""
+  exit 1
+fi

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -51,6 +51,16 @@ module Adhearsion
           dial_thread.join.should be_true
         end
 
+        let(:options) { { :foo => :bar } }
+
+        def dial_in_thread
+          Thread.new do
+            status = subject.dial to, options
+            latch.countdown!
+            status
+          end
+        end
+
         describe "without a block" do
           before do
             flexmock(other_mock_call).should_receive(:dial).once.with(to, options)
@@ -58,16 +68,6 @@ module Adhearsion
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
           end
 
-          let(:options) { { :foo => :bar } }
-
-          def dial_in_thread
-            Thread.new do
-              status = subject.dial to, options
-              latch.countdown!
-              status
-            end
-          end
-
           it "blocks the original controller until the new call ends" do
             dial_in_thread
 
@@ -166,6 +166,21 @@ module Adhearsion
           end
         end
 
+        describe "when the caller has already hung up" do
+          before do
+            call << mock_end
+          end
+
+          it "should raise Call::Hangup" do
+            expect { subject.dial to, options }.to raise_error(Call::Hangup)
+          end
+
+          it "should not make any outbound calls" do
+            flexmock(OutboundCall).should_receive(:new).never
+            expect { subject.dial to, options }.to raise_error
+          end
+        end
+
         describe "with multiple third parties specified" do
           let(:options) { {} }
           let(:other_options) { options }
@@ -374,6 +389,86 @@ module Adhearsion
             status.result.should be == :timeout
           end
         end
+
+        describe "with a confirmation controller" do
+          let(:confirmation_controller) do
+            latch = confirmation_latch
+            Class.new(Adhearsion::CallController) do
+              @@confirmation_latch = latch
+
+              def run
+                @@confirmation_latch.countdown!
+                call['confirm'] || hangup
+              end
+            end
+          end
+
+          let(:confirmation_latch) { CountDownLatch.new 1 }
+
+          let(:options) { {:confirm => confirmation_controller} }
+
+          before do
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+          end
+
+          context "when an outbound call is answered" do
+            it "should execute the specified confirmation controller" do
+              flexmock(other_mock_call).should_receive(:hangup).twice.and_return do
+                other_mock_call << mock_end
+              end
+              other_mock_call['confirm'] = false
+
+              dial_in_thread
+
+              latch.wait(0.1).should be_false
+
+              other_mock_call << mock_answered
+
+              confirmation_latch.wait(1).should be_true
+              latch.wait(2).should be_true
+            end
+
+            it "should join the calls if the call is still active after execution of the call controller" do
+              flexmock(other_mock_call).should_receive(:hangup).once
+              other_mock_call['confirm'] = true
+              flexmock(other_mock_call).should_receive(:join).once.with(call)
+
+              t = 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
+
+              t.join
+              status = t.value
+              status.result.should be == :answer
+            end
+
+            it "should not join the calls if the call is not active after execution of the call controller" do
+              flexmock(other_mock_call).should_receive(:hangup).twice.and_return do
+                other_mock_call << mock_end
+              end
+              other_mock_call['confirm'] = false
+              flexmock(other_mock_call).should_receive(:join).never.with(call)
+
+              t = dial_in_thread
+
+              latch.wait(1).should be_false
+
+              other_mock_call << mock_answered
+
+              latch.wait(1).should be_true
+
+              t.join
+              status = t.value
+              status.result.should be == :unconfirmed
+            end
+          end
+        end
       end#describe #dial
     end
   end

data/spec/adhearsion/call_controller/input_spec.rb

@@ -164,7 +164,7 @@ module Adhearsion
 
         it "executes failure hook and returns :failure if menu fails" do
           menu_instance.should_receive(:should_continue?).and_return(false)
-          menu_instance.should_receive(:execute_failure_hook)
+          menu_instance.should_receive(:execute_failure_hook).once
           result = subject.menu sound_files
           result.menu.should be menu_instance
           result.response.should be response
@@ -173,8 +173,8 @@ module Adhearsion
         it "executes invalid hook if input is invalid" do
           menu_instance.should_receive(:should_continue?).twice.and_return(true)
           menu_instance.should_receive(:continue).and_return(result_invalid, result_done)
-          menu_instance.should_receive(:execute_invalid_hook)
-          menu_instance.should_receive(:restart!)
+          menu_instance.should_receive(:execute_invalid_hook).once
+          menu_instance.should_receive(:restart!).once
           result = subject.menu sound_files
           result.menu.should be menu_instance
           result.response.should be response
@@ -184,8 +184,8 @@ module Adhearsion
           menu_instance.should_receive(:should_continue?).twice.and_return(true)
           menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
           subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
-          menu_instance.should_receive(:execute_timeout_hook)
-          menu_instance.should_receive(:restart!)
+          menu_instance.should_receive(:execute_timeout_hook).once
+          menu_instance.should_receive(:restart!).once
           subject.menu sound_files
         end
 
@@ -193,7 +193,7 @@ module Adhearsion
           menu_instance.should_receive(:should_continue?).twice.and_return(true)
           menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
           subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return("1")
-          menu_instance.should_receive(:<<).with("1")
+          menu_instance.should_receive(:<<).with("1").once
           subject.menu sound_files
         end
 
@@ -201,14 +201,14 @@ module Adhearsion
           menu_instance.should_receive(:should_continue?).and_return(true)
           menu_instance.should_receive(:continue).and_return(result_get_another_or_finish)
           subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
-          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension)
+          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension).once
           subject.menu sound_files
         end
 
         it "jumps to payload when result is found" do
           menu_instance.should_receive(:should_continue?).and_return(true)
           menu_instance.should_receive(:continue).and_return(result_found)
-          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension)
+          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension).once
           result = subject.menu sound_files
           result.menu.should be menu_instance
           result.response.should be response
@@ -238,11 +238,8 @@ module Adhearsion
           let(:result_get_another_or_finish)  { MenuDSL::Menu::MenuGetAnotherDigitOrFinish.new(:match_object, :new_extension) }
           let(:result_found)                  { MenuDSL::Menu::MenuResultFound.new(:match_object, :new_extension) }
 
-          let(:status)    { :foo }
-          let(:response)  { '1234' }
-
           before do
-            flexmock menu_instance, :status => status, :result => response
+            flexmock menu_instance
             flexmock(MenuDSL::Menu).should_receive(:new).and_return(menu_instance)
           end
 
@@ -250,35 +247,36 @@ module Adhearsion
             menu_instance.should_receive(:continue).and_return(result_done)
             result = subject.ask sound_files
             result.menu.should be menu_instance
-            result.response.should be response
+            result.response.should == ''
           end
 
           it "exits the function if MenuTerminated" do
             menu_instance.should_receive(:continue).and_return(result_terminated)
             result = subject.ask sound_files
             result.menu.should be menu_instance
-            result.response.should be response
+            result.response.should == ''
           end
 
           it "exits the function if MenuLimitReached" do
             menu_instance.should_receive(:continue).and_return(result_limit_reached)
             result = subject.ask sound_files
             result.menu.should be menu_instance
-            result.response.should be response
+            result.response.should == ''
           end
 
           it "plays audio, then executes timeout hook if input times out" do
             menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
-            subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
-            menu_instance.should_receive(:execute_timeout_hook)
-            menu_instance.should_receive(:restart!)
-            subject.ask sound_files
+            subject.should_receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return(nil)
+            result = subject.ask sound_files
+            result.menu.should be menu_instance
+            result.response.should be == ''
+            result.status.should be :timeout
           end
 
           it "plays audio, then adds digit to digit buffer if input is received" do
             menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
-            subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return("1")
-            menu_instance.should_receive(:<<).with("1")
+            subject.should_receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return("1")
+            menu_instance.should_receive(:<<).with("1").once
             subject.ask sound_files
           end
         end

data/spec/adhearsion/call_controller/output/async_player_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    module Output
+      describe AsyncPlayer do
+        include CallControllerTestHelpers
+
+        let(:controller) { flexmock new_controller }
+
+        subject { AsyncPlayer.new controller }
+
+        describe "#output" do
+          let(:content) { RubySpeech::SSML.draw { string "BOO" } }
+
+          it "should execute an output component with the provided SSML content" do
+            component = Punchblock::Component::Output.new :ssml => content
+            expect_message_waiting_for_response component
+            subject.output content
+          end
+
+          it "should allow extra options to be passed to the output component" do
+            component = Punchblock::Component::Output.new :ssml => content, :start_paused => true
+            expect_message_waiting_for_response component
+            subject.output content, :start_paused => true
+          end
+
+          it "returns the component" do
+            component = Punchblock::Component::Output.new :ssml => content
+            expect_message_waiting_for_response component
+            subject.output(content).should be_a Punchblock::Component::Output
+          end
+
+          it "raises a PlaybackError if the component fails to start" do
+            expect_message_waiting_for_response Punchblock::Component::Output.new(:ssml => content), Punchblock::ProtocolError
+            lambda { subject.output content }.should raise_error(PlaybackError)
+          end
+
+          it "logs the complete event if it is an error" do
+            response = Punchblock::Event::Complete.new
+            response.reason = Punchblock::Event::Complete::Error.new
+            component = Punchblock::Component::Output.new(:ssml => content)
+            flexmock subject, :new_output => component
+            expect_message_waiting_for_response component
+            flexmock(controller.logger).should_receive(:error).once
+            subject.output content
+            component.request!
+            component.execute!
+            component.trigger_event_handler response
+          end
+        end
+
+        describe "#play_ssml" do
+          let(:ssml) { RubySpeech::SSML.draw { string "BOO" } }
+
+          it 'executes an Output with the correct ssml' do
+            component = Punchblock::Component::Output.new :ssml => ssml.to_s
+            expect_message_waiting_for_response component
+            subject.play_ssml ssml
+          end
+        end
+      end
+    end
+  end
+end