punchblock 2.6.0 → 2.7.0

data/spec/punchblock/translator/asterisk/component/asterisk/agi_command_spec.rb

@@ -112,22 +112,31 @@ module Punchblock
               context 'of type start'
 
               context 'of type Exec' do
+                let (:ami_event_result) { "200%20result=123%20(timeout)%0A" }
                 let(:ami_event) do
                   RubyAMI::Event.new 'AsyncAGI',
                     "SubEvent"   => "Exec",
                     "Channel"    => channel,
                     "CommandId"  => component_id,
                     "Command"    => "EXEC ANSWER",
-                    "Result"     => "200%20result=123%20(timeout)%0A"
+                    "Result"     => ami_event_result
                 end
 
+                let(:ami_event_ast13) do
+                  RubyAMI::Event.new 'AsyncAGIExec',
+                    "Channel"    => channel,
+                    "CommandId"  => component_id,
+                    "Command"    => "EXEC ANSWER",
+                    "Result"     => ami_event_result
+                  end
+
                 let :expected_complete_reason do
                   Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new :code    => 200,
                                                                                        :result  => 123,
                                                                                        :data    => 'timeout'
                 end
 
-                it 'should send a complete event' do
+                def should_send_complete_event
                   subject.handle_ami_event ami_event
 
                   complete_event = original_command.complete_event 0.5
@@ -138,6 +147,50 @@ module Punchblock
                   expect(complete_event.reason).to eq(expected_complete_reason)
                 end
 
+                it 'should send a complete event' do
+                  should_send_complete_event
+                end
+
+                context 'with an AsyncAGIExec event' do
+                  let(:ami_event) { ami_event_ast13 }
+
+                  it 'should send a complete event' do
+                    should_send_complete_event
+                  end
+                end
+
+                context 'when the result contains illegal characters in the AGI response' do
+                  let (:ami_event_result) { '$' }
+                  let :expected_complete_reason do
+                    Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new :code    => -1,
+                                                                                         :result  => nil,
+                                                                                         :data    => nil
+                  end
+
+                  def treat_as_failure
+                    subject.handle_ami_event ami_event
+
+                    complete_event = original_command.complete_event 0.5
+
+                    expect(original_command).to be_complete
+
+                    expect(complete_event.component_id).to eq(component_id.to_s)
+                    expect(complete_event.reason).to eq(expected_complete_reason)
+                  end
+
+                  it 'treats it as a failure with code -1' do
+                    treat_as_failure
+                  end
+
+                  context 'with an AsyncAGIExec event' do
+                    let(:ami_event) { ami_event_ast13 }
+
+                    it 'treats it as a failure with code -1' do
+                      treat_as_failure
+                    end
+                  end
+                end
+
                 context "when the command was ASYNCAGI BREAK" do
                   let :original_command do
                     Punchblock::Component::Asterisk::AGI::Command.new :name => 'ASYNCAGI BREAK'

data/spec/punchblock/translator/asterisk/component/composed_prompt_spec.rb

@@ -76,11 +76,18 @@ module Punchblock
             original_command.request!
           end
 
+          let (:ast13mode) { false }
+
           def ami_event_for_dtmf(digit, position)
-            RubyAMI::Event.new 'DTMF',
-              'Digit' => digit.to_s,
-              'Start' => position == :start ? 'Yes' : 'No',
-              'End'   => position == :end ? 'Yes' : 'No'
+            if ast13mode
+              RubyAMI::Event.new 'DTMF' + (position == :start ? 'Begin' : '') + (position == :end ? 'End' : ''),
+                'Digit' => digit.to_s
+            else
+              RubyAMI::Event.new 'DTMF',
+                'Digit' => digit.to_s,
+                'Start' => position == :start ? 'Yes' : 'No',
+                'End'   => position == :end ? 'Yes' : 'No'
+            end
           end
 
           def send_ami_events_for_dtmf(digit)
@@ -163,7 +170,7 @@ module Punchblock
                     Punchblock::Component::Input::Complete::Match.new nlsml: expected_nlsml
                   end
 
-                  it "should return a match complete event" do
+                  def should_return_a_match_complete_event
                     expected_event
                     subject.execute
                     expect(original_command.response(0.1)).to be_a Ref
@@ -171,6 +178,18 @@ module Punchblock
 
                     expect(connection.events).to include(expected_event)
                   end
+
+                  it "should return a match complete event" do
+                    should_return_a_match_complete_event
+                  end
+
+                  context 'with Asterisk 13 DTMFEnd event' do
+                    let (:ast13mode) { true }
+
+                    it "should return a match complete event" do
+                      should_return_a_match_complete_event
+                    end
+                  end
                 end
 
                 context "when not receiving any DTMF input at all" do

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

@@ -52,11 +52,18 @@ module Punchblock
               { :mode => :dtmf, :grammar => { :value => grammar } }.merge(original_command_opts)
             end
 
+            let (:ast13mode) { false }
+
             def ami_event_for_dtmf(digit, position)
-              RubyAMI::Event.new 'DTMF',
-                'Digit' => digit.to_s,
-                'Start' => position == :start ? 'Yes' : 'No',
-                'End'   => position == :end ? 'Yes' : 'No'
+              if ast13mode
+                RubyAMI::Event.new 'DTMF' + (position == :start ? 'Begin' : '') + (position == :end ? 'End' : ''),
+                  'Digit' => digit.to_s
+              else
+                RubyAMI::Event.new 'DTMF',
+                  'Digit' => digit.to_s,
+                  'Start' => position == :start ? 'Yes' : 'No',
+                  'End'   => position == :end ? 'Yes' : 'No'
+              end
             end
 
             def send_ami_events_for_dtmf(digit)
@@ -101,7 +108,14 @@ module Punchblock
                 end
 
                 it "should not leave the recognizer running" do
-                  expect(Celluloid::Actor.all.map { |a| a.class }).not_to include(Punchblock::Translator::DTMFRecognizer)
+                  expect(Celluloid::Actor.all.any? { |a| a.class == Punchblock::Translator::DTMFRecognizer rescue false }).to eq(false)
+                end
+
+                context 'with an Asterisk 13 DTMFEnd event' do
+                  let(:ast13mode) { true }
+                  it "should send a success complete event with the relevant data" do
+                    expect(reason).to eq(expected_event)
+                  end
                 end
               end
 
@@ -118,6 +132,13 @@ module Punchblock
                 it "should send a nomatch complete event" do
                   expect(reason).to eq(expected_event)
                 end
+
+                context 'with an Asterisk 13 DTMFEnd event' do
+                  let(:ast13mode) { true }
+                  it "should send a nomatch complete event" do
+                    expect(reason).to eq(expected_event)
+                  end
+                end
               end
 
               context "dtmf event received after recognizer has terminated" do

data/spec/punchblock/translator/asterisk/component/mrcp_native_prompt_spec.rb

@@ -51,10 +51,11 @@ module Punchblock
 
           let(:output_command_opts) { {} }
 
-          let(:audio_filename) { 'http://example.com/hello.mp3' }
+          let(:audio_filename) { '/var/foo' }
+          let(:audio_path) { "file://#{audio_filename}.wav" }
 
           let :output_command_options do
-            { render_document: {value: [audio_filename], content_type: 'text/uri-list'} }.merge(output_command_opts)
+            { render_document: {value: [audio_path], content_type: 'text/uri-list'} }.merge(output_command_opts)
           end
 
           let(:input_command_opts) { {} }
@@ -158,6 +159,23 @@ module Punchblock
               end
             end
 
+            context 'with multiple audio tags in SSML' do
+              let :ssml_doc do
+                RubySpeech::SSML.draw do
+                  audio(src: audio_path)
+                  audio(src: audio_path)
+                end
+              end
+
+              let(:output_command_options) { { render_documents: [{value: ssml_doc}] } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'Only one audio file is allowed.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
             context 'unset' do
               let(:output_command_options) { {} }
 
@@ -181,6 +199,28 @@ module Punchblock
                   expect(original_command.response(0.1)).to be_a Ref
                 end
 
+                context "when the render document is SSML" do
+                  let :ssml_doc do
+                    RubySpeech::SSML.draw do
+                      audio(src: audio_path)
+                    end
+                  end
+
+                  let(:output_command_opts) do
+                    {
+                      renderer: renderer,
+                      render_document: {value: ssml_doc}
+                    }
+                  end
+
+                  it "should return a ref and execute MRCPRecog" do
+                    param = ["\"#{grammar.to_doc.to_s.squish.gsub('"', '\"')}\"", "uer=1&b=1&f=#{audio_filename}"].join(',')
+                    expect(mock_call).to receive(:execute_agi_command).once.with('EXEC MRCPRecog', param).and_return code: 200, result: 1
+                    subject.execute
+                    expect(original_command.response(0.1)).to be_a Ref
+                  end
+                end
+
                 context "when MRCPRecog completes" do
                   shared_context "with a match" do
                     let :expected_nlsml do

data/spec/punchblock/translator/asterisk/component/mrcp_prompt_spec.rb

@@ -612,6 +612,485 @@ module Punchblock
             end
           end
 
+          describe 'Input#max-silence' do
+            context 'a positive number' do
+              let(:input_command_opts) { { max_silence: 1000 } }
+
+              it 'should pass the sint option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sint=1000/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { max_silence: 0 } }
+
+              it 'should pass the sint option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sint=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { max_silence: -1000 } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A max-silence value must be -1, 0, or a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { max_silence: nil } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#speech-complete-timeout' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"Speech-Complete-Timeout" => 1000 } } }
+
+              it 'should pass the sct option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sct=1000/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"Speech-Complete-Timeout" => 0 } } }
+
+              it 'should pass the sct option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sct=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"Speech-Complete-Timeout" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A speech-complete-timeout value must be -1, 0, or a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Speech-Complete-Timeout" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Speed-Vs-Accuracy)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"Speed-Vs-Accuracy" => 1 } } }
+
+              it 'should pass the sva option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sva=1/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"Speed-Vs-Accuracy" => 0 } } }
+
+              it 'should pass the sva option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sva=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"Speed-Vs-Accuracy" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A speed-vs-accuracy value must be a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Speed-Vs-Accuracy" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(N-Best-List-Length)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"N-Best-List-Length" => 5 } } }
+
+              it 'should pass the nb option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/nb=5/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"N-Best-List-Length" => 0 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'An n-best-list-length value must be a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"N-Best-List-Length" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'An n-best-list-length value must be a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"N-Best-List-Length" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Start-Input-Timers)' do
+            context 'true' do
+              let(:input_command_opts) { { headers: {"Start-Input-Timers" => true } } }
+
+              it 'should pass the sit option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sit=true/)
+                subject.execute
+              end
+            end
+
+            context 'false' do
+              let(:input_command_opts) { { headers: {"Start-Input-Timers" => false } } }
+
+              it 'should pass the sit option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sit=false/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Start-Input-Timers" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(DTMF-Terminate-Timeout)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"DTMF-Terminate-Timeout" => 1000 } } }
+
+              it 'should pass the dtt option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/dtt=1000/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"DTMF-Terminate-Timeout" => 0 } } }
+
+              it 'should pass the dtt option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/dtt=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"DTMF-Terminate-Timeout" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A dtmf-terminate-timeout value must be -1, 0, or a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"DTMF-Terminate-Timeout" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Save-Waveform)' do
+            context 'true' do
+              let(:input_command_opts) { { headers: {"Save-Waveform" => true } } }
+
+              it 'should pass the sw option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sw=true/)
+                subject.execute
+              end
+            end
+
+            context 'false' do
+              let(:input_command_opts) { { headers: {"Save-Waveform" => false } } }
+
+              it 'should pass the sw option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/sw=false/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Save-Waveform" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(New-Audio-Channel)' do
+            context 'true' do
+              let(:input_command_opts) { { headers: {"New-Audio-Channel" => true } } }
+
+              it 'should pass the nac option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/nac=true/)
+                subject.execute
+              end
+            end
+
+            context 'false' do
+              let(:input_command_opts) { { headers: {"New-Audio-Channel" => false } } }
+
+              it 'should pass the nac option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/nac=false/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"New-Audio-Channel" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Recognition-Mode)' do
+            context 'a string' do
+              let(:input_command_opts) { { headers: {"Recognition-Mode" => "hotword" } } }
+
+              it 'should pass the rm option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/rm=hotword/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Recognition-Mode" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Hotword-Max-Duration)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"Hotword-Max-Duration" => 1000 } } }
+
+              it 'should pass the hmaxd option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/hmaxd=1000/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"Hotword-Max-Duration" => 0 } } }
+
+              it 'should pass the hmaxd option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/hmaxd=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"Hotword-Max-Duration" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A hotword-max-duration value must be -1, 0, or a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Hotword-Max-Duration" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Hotword-Min-Duration)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"Hotword-Min-Duration" => 1000 } } }
+
+              it 'should pass the hmind option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/hmind=1000/)
+                subject.execute
+              end
+            end
+
+            context '0' do
+              let(:input_command_opts) { { headers: {"Hotword-Min-Duration" => 0 } } }
+
+              it 'should pass the hmind option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/hmind=0/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"Hotword-Min-Duration" => -1000 } } }
+
+              it "should return an error and not execute any actions" do
+                subject.execute
+                error = ProtocolError.new.setup 'option error', 'A hotword-min-duration value must be -1, 0, or a positive integer.'
+                expect(original_command.response(0.1)).to eq(error)
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Hotword-Min-Duration" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Clear-DTMF-Buffer)' do
+            context 'true' do
+              let(:input_command_opts) { { headers: {"Clear-DTMF-Buffer" => true } } }
+
+              it 'should pass the cdb option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/cdb=true/)
+                subject.execute
+              end
+            end
+
+            context 'false' do
+              let(:input_command_opts) { { headers: {"Clear-DTMF-Buffer" => false } } }
+
+              it 'should pass the cdb option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/cdb=false/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Clear-DTMF-Buffer" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Early-No-Match)' do
+            context 'true' do
+              let(:input_command_opts) { { headers: {"Early-No-Match" => true } } }
+
+              it 'should pass the enm option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/enm=true/)
+                subject.execute
+              end
+            end
+
+            context 'a negative number' do
+              let(:input_command_opts) { { headers: {"Early-No-Match" => false } } }
+
+              it "should return an error and not execute any actions" do
+                expect_synthandrecog_with_options(/enm=false/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Early-No-Match" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Input-Waveform-URI)' do
+            context 'a positive number' do
+              let(:input_command_opts) { { headers: {"Input-Waveform-URI" => 'http://wave.form.com' } } }
+
+              it 'should pass the iwu option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/iwu=http:\/\/wave\.form\.com/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Input-Waveform-URI" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
+          describe 'Input#headers(Media-Type)' do
+            context 'a string' do
+              let(:input_command_opts) { { headers: {"Media-Type" => "foo/type" } } }
+
+              it 'should pass the mt option to SynthAndRecog' do
+                expect_synthandrecog_with_options(/mt=foo\/type/)
+                subject.execute
+              end
+            end
+
+            context 'unset' do
+              let(:input_command_opts) { { headers: {"Media-Type" => nil } } }
+
+              it 'should not pass any options to SynthAndRecog' do
+                expect_synthandrecog_with_options(//)
+                subject.execute
+              end
+            end
+          end
+
           describe 'Input#mode' do
             pending
           end