punchblock 1.3.0 → 1.4.0

data/spec/punchblock/translator/freeswitch/component/flite_output_spec.rb

@@ -0,0 +1,279 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        describe FliteOutput do
+          let(:connection) do
+            mock_connection_with_event_handler do |event|
+              original_command.add_event event
+            end
+          end
+          let(:media_engine)  { :flite }
+          let(:default_voice) { nil }
+          let(:translator)    { Punchblock::Translator::Freeswitch.new connection }
+          let(:mock_call)     { Punchblock::Translator::Freeswitch::Call.new 'foo', translator }
+
+          let :original_command do
+            Punchblock::Component::Output.new command_options
+          end
+
+          let :ssml_doc do
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => :cardinal) { 'FOO' }
+            end
+          end
+
+          let :command_options do
+            { :ssml => ssml_doc }
+          end
+
+          def execute
+            subject.execute media_engine, default_voice
+          end
+
+          subject { described_class.new original_command, mock_call }
+
+          describe '#execute' do
+            before { original_command.request! }
+            def expect_playback(voice = :kal)
+              subject.wrapped_object.expects(:application).once.with :speak, "#{media_engine}|#{voice}|FOO"
+            end
+
+            let(:command_opts) { {} }
+
+            let :command_options do
+              { :ssml => ssml_doc }.merge(command_opts)
+            end
+
+            let :original_command do
+              Punchblock::Component::Output.new command_options
+            end
+
+            describe 'ssml' do
+              context 'unset' do
+                let(:command_opts) { { :ssml => nil } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'An SSML document is required.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context 'with an SSML node' do
+                it 'should speak the document using the speak application' do
+                  expect_playback
+                  execute
+                end
+
+                it 'should send a complete event when the speak finishes' do
+                  expect_playback.yields true
+                  execute
+                  subject.handle_es_event RubyFS::Event.new(nil, :event_name => "CHANNEL_EXECUTE_COMPLETE")
+                  original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                end
+              end
+            end
+
+            describe 'start-offset' do
+              context 'unset' do
+                let(:command_opts) { { :start_offset => nil } }
+                it 'should not pass any options to Playback' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'set' do
+                let(:command_opts) { { :start_offset => 10 } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'A start_offset value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'start-paused' do
+              context 'false' do
+                let(:command_opts) { { :start_paused => false } }
+                it 'should not pass any options to Playback' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'true' do
+                let(:command_opts) { { :start_paused => true } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'A start_paused value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'repeat-interval' do
+              context 'unset' do
+                let(:command_opts) { { :repeat_interval => nil } }
+                it 'should not pass any options to Playback' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'set' do
+                let(:command_opts) { { :repeat_interval => 10 } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'A repeat_interval value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'repeat-times' do
+              context 'unset' do
+                let(:command_opts) { { :repeat_times => nil } }
+                it 'should not pass any options to Playback' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'set' do
+                let(:command_opts) { { :repeat_times => 2 } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'A repeat_times value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'max-time' do
+              context 'unset' do
+                let(:command_opts) { { :max_time => nil } }
+                it 'should not pass any options to Playback' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'set' do
+                let(:command_opts) { { :max_time => 30 } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'A max_time value is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'voice' do
+              context 'unset' do
+                let(:command_opts) { { :voice => nil } }
+                it 'should use the default voice' do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context 'set' do
+                let(:command_opts) { { :voice => 'alison' } }
+                it "should execute speak with the specified voice" do
+                  expect_playback 'alison'
+                  execute
+                end
+              end
+            end
+
+            describe 'interrupt_on' do
+              context "set to nil" do
+                let(:command_opts) { { :interrupt_on => nil } }
+                it "should not pass any digits to Playback" do
+                  expect_playback
+                  execute
+                end
+              end
+
+              context "set to :any" do
+                let(:command_opts) { { :interrupt_on => :any } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'An interrupt-on value of any is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context "set to :dtmf" do
+                let(:command_opts) { { :interrupt_on => :dtmf } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'An interrupt-on value of dtmf is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context "set to :speech" do
+                let(:command_opts) { { :interrupt_on => :speech } }
+                it "should return an error and not execute any actions" do
+                  execute
+                  error = ProtocolError.new.setup 'option error', 'An interrupt-on value of speech is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+          end
+
+          describe "#execute_command" do
+            context "with a command it does not understand" do
+              let(:command) { Punchblock::Component::Output::Pause.new }
+
+              before { command.request! }
+
+              it "returns a ProtocolError response" do
+                subject.execute_command command
+                command.response(0.1).should be_a ProtocolError
+              end
+            end
+
+            context "with a Stop command" do
+              let(:command) { Punchblock::Component::Stop.new }
+              let(:reason) { original_command.complete_event(5).reason }
+
+              before do
+                command.request!
+                original_command.request!
+                original_command.execute!
+              end
+
+              it "sets the command response to true" do
+                subject.wrapped_object.expects(:application)
+                subject.execute_command command
+                command.response(0.1).should be == true
+              end
+
+              it "sends the correct complete event" do
+                subject.wrapped_object.expects(:application)
+                original_command.should_not be_complete
+                subject.execute_command command
+                reason.should be_a Punchblock::Event::Complete::Stop
+                original_command.should be_complete
+              end
+
+              it "breaks the current dialplan application" do
+                subject.wrapped_object.expects(:application).once.with 'break'
+                subject.execute_command command
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/punchblock/translator/freeswitch/component/input_spec.rb

@@ -0,0 +1,312 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Punchblock
+  module Translator
+    class Freeswitch
+      module Component
+        describe Input do
+          let(:connection) do
+            mock_connection_with_event_handler do |event|
+              original_command.add_event event
+            end
+          end
+          let(:id)          { Punchblock.new_uuid }
+          let(:translator)  { Punchblock::Translator::Freeswitch.new connection }
+          let(:mock_stream) { mock('RubyFS::Stream') }
+          let(:call)        { Punchblock::Translator::Freeswitch::Call.new id, translator, nil, mock_stream }
+
+          let(:original_command_options) { {} }
+
+          let :original_command do
+            Punchblock::Component::Input.new original_command_options
+          end
+
+          let :grammar do
+            RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'pin' do
+              rule id: 'digit' do
+                one_of do
+                  0.upto(9) { |d| item { d.to_s } }
+                end
+              end
+
+              rule id: 'pin', scope: 'public' do
+                item repeat: '2' do
+                  ruleref uri: '#digit'
+                end
+              end
+            end
+          end
+
+          subject { Input.new original_command, call }
+
+          describe '#execute' do
+            before { original_command.request! }
+
+            let(:original_command_opts) { {} }
+
+            let :original_command_options do
+              { :mode => :dtmf, :grammar => { :value => grammar } }.merge(original_command_opts)
+            end
+
+            def dtmf_event(digit)
+              RubyFS::Event.new nil, {
+                :event_name     => 'DTMF',
+                :dtmf_digit     => digit.to_s,
+                :dtmf_duration  => "1600"
+              }
+            end
+
+            def send_dtmf(digit)
+              call.handle_es_event dtmf_event(digit)
+            end
+
+            let(:reason) { original_command.complete_event(5).reason }
+
+            describe "receiving DTMF events" do
+              before do
+                subject.execute
+                expected_event
+              end
+
+              context "when a match is found" do
+                before do
+                  send_dtmf 1
+                  send_dtmf 2
+                end
+
+                let :expected_event do
+                  Punchblock::Component::Input::Complete::Success.new :mode => :dtmf,
+                    :confidence => 1,
+                    :utterance => '12',
+                    :interpretation => 'dtmf-1 dtmf-2',
+                    :component_id => subject.id,
+                    :target_call_id => call.id
+                end
+
+                it "should send a success complete event with the relevant data" do
+                  reason.should be == expected_event
+                end
+
+                it "should not process further dtmf events" do
+                  subject.expects(:process_dtmf!).never
+                  send_dtmf 3
+                end
+              end
+
+              context "when the match is invalid" do
+                before do
+                  send_dtmf 1
+                  send_dtmf '#'
+                end
+
+                let :expected_event do
+                  Punchblock::Component::Input::Complete::NoMatch.new :component_id => subject.id,
+                                                                      :target_call_id => call.id
+                end
+
+                it "should send a nomatch complete event" do
+                  reason.should be == expected_event
+                end
+              end
+            end
+
+            describe 'grammar' do
+              context 'unset' do
+                let(:original_command_opts) { { :grammar => nil } }
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A grammar document is required.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'mode' do
+              context 'unset' do
+                let(:original_command_opts) { { :mode => nil } }
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A mode value other than DTMF is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context 'any' do
+                let(:original_command_opts) { { :mode => :any } }
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A mode value other than DTMF is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+
+              context 'speech' do
+                let(:original_command_opts) { { :mode => :speech } }
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'A mode value other than DTMF is unsupported.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'terminator' do
+              pending
+            end
+
+            describe 'recognizer' do
+              pending
+            end
+
+            describe 'initial-timeout' do
+              context 'a positive number' do
+                let(:original_command_opts) { { :initial_timeout => 1000 } }
+
+                it "should not cause a NoInput if first input is received in time" do
+                  subject.execute
+                  send_dtmf 1
+                  sleep 1.5
+                  send_dtmf 2
+                  reason.should be_a Punchblock::Component::Input::Complete::Success
+                end
+
+                it "should cause a NoInput complete event to be sent after the timeout" do
+                  subject.execute
+                  sleep 1.5
+                  send_dtmf 1
+                  send_dtmf 2
+                  reason.should be_a Punchblock::Component::Input::Complete::NoInput
+                end
+              end
+
+              context '-1' do
+                let(:original_command_opts) { { :initial_timeout => -1 } }
+
+                it "should not start a timer" do
+                  subject.wrapped_object.expects(:begin_initial_timer).never
+                  subject.execute
+                end
+              end
+
+              context 'unset' do
+                let(:original_command_opts) { { :initial_timeout => nil } }
+
+                it "should not start a timer" do
+                  subject.wrapped_object.expects(:begin_initial_timer).never
+                  subject.execute
+                end
+              end
+
+              context 'a negative number other than -1' do
+                let(:original_command_opts) { { :initial_timeout => -1000 } }
+
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'An initial timeout value that is negative (and not -1) is invalid.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'inter-digit-timeout' do
+              context 'a positive number' do
+                let(:original_command_opts) { { :inter_digit_timeout => 1000 } }
+
+                it "should not prevent a Match if input is received in time" do
+                  subject.execute
+                  sleep 1.5
+                  send_dtmf 1
+                  sleep 0.5
+                  send_dtmf 2
+                  reason.should be_a Punchblock::Component::Input::Complete::Success
+                end
+
+                it "should cause a NoMatch complete event to be sent after the timeout" do
+                  subject.execute
+                  sleep 1.5
+                  send_dtmf 1
+                  sleep 1.5
+                  send_dtmf 2
+                  reason.should be_a Punchblock::Component::Input::Complete::NoMatch
+                end
+              end
+
+              context '-1' do
+                let(:original_command_opts) { { :inter_digit_timeout => -1 } }
+
+                it "should not start a timer" do
+                  subject.wrapped_object.expects(:begin_inter_digit_timer).never
+                  subject.execute
+                end
+              end
+
+              context 'unset' do
+                let(:original_command_opts) { { :inter_digit_timeout => nil } }
+
+                it "should not start a timer" do
+                  subject.wrapped_object.expects(:begin_inter_digit_timer).never
+                  subject.execute
+                end
+              end
+
+              context 'a negative number other than -1' do
+                let(:original_command_opts) { { :inter_digit_timeout => -1000 } }
+
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'An inter-digit timeout value that is negative (and not -1) is invalid.'
+                  original_command.response(0.1).should be == error
+                end
+              end
+            end
+
+            describe 'sensitivity' do
+              pending
+            end
+
+            describe 'min-confidence' do
+              pending
+            end
+
+            describe 'max-silence' do
+              pending
+            end
+          end
+
+          describe "#execute_command" do
+            context "with a command it does not understand" do
+              let(:command) { Punchblock::Component::Output::Pause.new }
+
+              before { command.request! }
+
+              it "returns a ProtocolError response" do
+                subject.execute_command command
+                command.response(0.1).should be_a ProtocolError
+              end
+            end
+
+            context "with a Stop command" do
+              let(:command) { Punchblock::Component::Stop.new }
+              let(:reason) { original_command.complete_event(5).reason }
+
+              before do
+                command.request!
+                original_command.request!
+                original_command.execute!
+              end
+
+              it "sets the command response to true" do
+                subject.execute_command command
+                command.response(0.1).should be == true
+                reason.should be_a Punchblock::Event::Complete::Stop
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end