punchblock 0.8.4 → 0.9.0

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

@@ -1,284 +0,0 @@
-require 'spec_helper'
-
-module Punchblock
-  module Translator
-    class Asterisk
-      module Component
-        module Asterisk
-          describe Input do
-            let(:connection) do
-              mock_connection_with_event_handler do |event|
-                command.add_event event
-              end
-            end
-            let(:media_engine)    { nil }
-            let(:translator)      { Punchblock::Translator::Asterisk.new mock('AMI'), connection, media_engine }
-            let(:call)            { Punchblock::Translator::Asterisk::Call.new 'foo', translator }
-            let(:command_options) { {} }
-
-            let :command do
-              Punchblock::Component::Input.new 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 command, call }
-
-            describe '#execute' do
-              before { command.request! }
-
-              context 'with a media engine of :unimrcp' do
-                pending
-                let(:media_engine) { :unimrcp }
-              end
-
-              context 'with a media engine of :asterisk' do
-                let(:media_engine) { :asterisk }
-
-                let(:command_opts) { {} }
-
-                let :command_options do
-                  { :mode => :dtmf, :grammar => { :value => grammar } }.merge(command_opts)
-                end
-
-                def ami_event_for_dtmf(digit, position)
-                  RubyAMI::Event.new('DTMF').tap do |e|
-                    e['Digit']  = digit.to_s
-                    e['Start']  = position == :start ? 'Yes' : 'No'
-                    e['End']    = position == :end ? 'Yes' : 'No'
-                  end
-                end
-
-                def send_ami_events_for_dtmf(digit)
-                  call.process_ami_event ami_event_for_dtmf(digit, :start)
-                  call.process_ami_event ami_event_for_dtmf(digit, :end)
-                end
-
-                let(:reason) { 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_ami_events_for_dtmf 1
-                      send_ami_events_for_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,
-                                                                          :call_id => call.id
-                    end
-
-                    it "should send a success complete event with the relevant data" do
-                      reason.should == expected_event
-                    end
-                  end
-
-                  context "when the match is invalid" do
-                    before do
-                      send_ami_events_for_dtmf 1
-                      send_ami_events_for_dtmf '#'
-                    end
-
-                    let :expected_event do
-                      Punchblock::Component::Input::Complete::NoMatch.new :component_id => subject.id,
-                                                                          :call_id => call.id
-                    end
-
-                    it "should send a nomatch complete event" do
-                      reason.should == expected_event
-                    end
-                  end
-                end
-
-                describe 'grammar' do
-                  context 'unset' do
-                    let(:command_opts) { { :grammar => nil } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A grammar document is required.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'mode' do
-                  context 'unset' do
-                    let(:command_opts) { { :mode => nil } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A mode value other than DTMF is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-
-                  context 'any' do
-                    let(:command_opts) { { :mode => :any } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A mode value other than DTMF is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-
-                  context 'speech' do
-                    let(:command_opts) { { :mode => :speech } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A mode value other than DTMF is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'terminator' do
-                  pending
-                end
-
-                describe 'recognizer' do
-                  pending
-                end
-
-                describe 'initial-timeout' do
-                  context 'a positive number' do
-                    let(:command_opts) { { :initial_timeout => 1000 } }
-
-                    it "should not cause a NoInput if first input is received in time" do
-                      subject.execute
-                      send_ami_events_for_dtmf 1
-                      sleep 1.5
-                      send_ami_events_for_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_ami_events_for_dtmf 1
-                      send_ami_events_for_dtmf 2
-                      reason.should be_a Punchblock::Component::Input::Complete::NoInput
-                    end
-                  end
-
-                  context '-1' do
-                    let(: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(: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(:command_opts) { { :initial_timeout => -1000 } }
-
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An initial timeout value that is negative (and not -1) is invalid.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'inter-digit-timeout' do
-                  context 'a positive number' do
-                    let(: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_ami_events_for_dtmf 1
-                      sleep 0.5
-                      send_ami_events_for_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_ami_events_for_dtmf 1
-                      sleep 1.5
-                      send_ami_events_for_dtmf 2
-                      reason.should be_a Punchblock::Component::Input::Complete::NoMatch
-                    end
-                  end
-
-                  context '-1' do
-                    let(: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(: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(:command_opts) { { :inter_digit_timeout => -1000 } }
-
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An inter-digit timeout value that is negative (and not -1) is invalid.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'sensitivity' do
-                  pending
-                end
-
-                describe 'min-confidence' do
-                  pending
-                end
-
-                describe 'max-silence' do
-                  pending
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,493 +0,0 @@
-require 'spec_helper'
-
-module Punchblock
-  module Translator
-    class Asterisk
-      module Component
-        module Asterisk
-          describe Output do
-            let(:connection) do
-              mock_connection_with_event_handler do |event|
-                command.add_event event
-              end
-            end
-            let(:media_engine)  { nil }
-            let(:translator)    { Punchblock::Translator::Asterisk.new mock('AMI'), connection, media_engine }
-            let(:mock_call)     { Punchblock::Translator::Asterisk::Call.new 'foo', translator }
-
-            let :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
-
-            subject { Output.new command, mock_call }
-
-            describe '#execute' do
-              before { command.request! }
-
-              context 'with a media engine of :unimrcp' do
-                let(:media_engine) { :unimrcp }
-
-                let(:audio_filename) { 'http://foo.com/bar.mp3' }
-
-                let :ssml_doc do
-                  RubySpeech::SSML.draw do
-                    audio :src => audio_filename
-                    say_as(:interpret_as => :cardinal) { 'FOO' }
-                  end
-                end
-
-                let(:command_opts) { {} }
-
-                let :command_options do
-                  { :ssml => ssml_doc }.merge(command_opts)
-                end
-
-                def expect_mrcpsynth_with_options(options)
-                  mock_call.expects(:send_agi_action!).once.with do |*args|
-                    args[0].should == 'EXEC MRCPSynth'
-                    args[2].should match options
-                  end
-                end
-
-                it "should execute MRCPSynth" do
-                  mock_call.expects(:send_agi_action!).once.with 'EXEC MRCPSynth', ssml_doc.to_s.squish.gsub(/["\\]/) { |m| "\\#{m}" }, ''
-                  subject.execute
-                end
-
-                it 'should send a complete event when MRCPSynth completes' do
-                  def mock_call.send_agi_action!(*args, &block)
-                    block.call Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new(:code => 200, :result => 1)
-                  end
-                  subject.execute
-                  command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
-                end
-
-                describe 'ssml' do
-                  context 'unset' do
-                    let(:command_opts) { { :ssml => nil } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An SSML document is required.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'start-offset' do
-                  context 'unset' do
-                    let(:command_opts) { { :start_offset => nil } }
-                    it 'should not pass any options to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :start_offset => 10 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A start_offset value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'start-paused' do
-                  context 'false' do
-                    let(:command_opts) { { :start_paused => false } }
-                    it 'should not pass any options to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'true' do
-                    let(:command_opts) { { :start_paused => true } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A start_paused value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'repeat-interval' do
-                  context 'unset' do
-                    let(:command_opts) { { :repeat_interval => nil } }
-                    it 'should not pass any options to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :repeat_interval => 10 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A repeat_interval value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'repeat-times' do
-                  context 'unset' do
-                    let(:command_opts) { { :repeat_times => nil } }
-                    it 'should not pass any options to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :repeat_times => 2 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A repeat_times value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'max-time' do
-                  context 'unset' do
-                    let(:command_opts) { { :max_time => nil } }
-                    it 'should not pass any options to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :max_time => 30 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A max_time value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'voice' do
-                  context 'unset' do
-                    let(:command_opts) { { :voice => nil } }
-                    it 'should not pass the v option to MRCPSynth' do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :voice => 'alison' } }
-                    it 'should pass the v option to MRCPSynth' do
-                      expect_mrcpsynth_with_options(/v=alison/)
-                      subject.execute
-                    end
-                  end
-                end
-
-                describe 'interrupt_on' do
-                  context "set to nil" do
-                    let(:command_opts) { { :interrupt_on => nil } }
-                    it "should not pass the i option to MRCPSynth" do
-                      expect_mrcpsynth_with_options(//)
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :any" do
-                    let(:command_opts) { { :interrupt_on => :any } }
-                    it "should pass the i option to MRCPSynth" do
-                      expect_mrcpsynth_with_options(/i=any/)
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :dtmf" do
-                    let(:command_opts) { { :interrupt_on => :dtmf } }
-                    it "should pass the i option to MRCPSynth" do
-                      expect_mrcpsynth_with_options(/i=any/)
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :speech" do
-                    let(:command_opts) { { :interrupt_on => :speech } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An interrupt-on value of speech is unsupported.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-              end
-
-              context 'with a media engine of :asterisk' do
-                let(:media_engine) { :asterisk }
-
-                def expect_stream_file_with_options(options = nil)
-                  mock_call.expects(:send_agi_action!).once.with 'STREAM FILE', audio_filename, options do |*args|
-                    args[2].should == options
-                    subject.continue!
-                    true
-                  end
-                end
-
-                let(:audio_filename) { 'http://foo.com/bar.mp3' }
-
-                let :ssml_doc do
-                  RubySpeech::SSML.draw do
-                    audio :src => audio_filename
-                    say_as(:interpret_as => :cardinal) { 'FOO' }
-                  end
-                end
-
-                let(:command_opts) { {} }
-
-                let :command_options do
-                  { :ssml => ssml_doc }.merge(command_opts)
-                end
-
-                let :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
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An SSML document is required.'
-                      command.response(0.1).should == error
-                    end
-                  end
-
-                  context 'with a single audio SSML node' do
-                    let(:audio_filename) { 'http://foo.com/bar.mp3' }
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw { audio :src => audio_filename }
-                      }
-                    end
-
-                    it 'should playback the audio file using STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-
-                    it 'should send a complete event when the file finishes playback' do
-                      def mock_call.send_agi_action!(*args, &block)
-                        block.call Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new(:code => 200, :result => 1)
-                      end
-                      subject.execute
-                      command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
-                    end
-                  end
-
-                  context 'with multiple audio SSML nodes' do
-                    let(:audio_filename1) { 'http://foo.com/bar.mp3' }
-                    let(:audio_filename2) { 'http://foo.com/baz.mp3' }
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw do
-                          audio :src => audio_filename1
-                          audio :src => audio_filename2
-                        end
-                      }
-                    end
-
-                    it 'should playback each audio file using STREAM FILE' do
-                      latch = CountDownLatch.new 2
-                      mock_call.expects(:send_agi_action!).once.with 'STREAM FILE', audio_filename1, nil do
-                        subject.continue
-                        true
-                        latch.countdown!
-                      end
-                      mock_call.expects(:send_agi_action!).once.with 'STREAM FILE', audio_filename2, nil do
-                        subject.continue
-                        true
-                        latch.countdown!
-                      end
-                      subject.execute
-                      latch.wait 2
-                      sleep 2
-                    end
-
-                    it 'should send a complete event after the final file has finished playback' do
-                      def mock_call.send_agi_action!(*args, &block)
-                        block.call Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new(:code => 200, :result => 1)
-                      end
-                      command.expects(:add_event).once.with do |e|
-                        e.reason.should be_a Punchblock::Component::Output::Complete::Success
-                      end
-                      subject.execute
-                    end
-                  end
-                end
-
-                describe 'start-offset' do
-                  context 'unset' do
-                    let(:command_opts) { { :start_offset => nil } }
-                    it 'should not pass any options to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :start_offset => 10 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A start_offset value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'start-paused' do
-                  context 'false' do
-                    let(:command_opts) { { :start_paused => false } }
-                    it 'should not pass any options to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'true' do
-                    let(:command_opts) { { :start_paused => true } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A start_paused value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'repeat-interval' do
-                  context 'unset' do
-                    let(:command_opts) { { :repeat_interval => nil } }
-                    it 'should not pass any options to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :repeat_interval => 10 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A repeat_interval value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'repeat-times' do
-                  context 'unset' do
-                    let(:command_opts) { { :repeat_times => nil } }
-                    it 'should not pass any options to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :repeat_times => 2 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A repeat_times value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'max-time' do
-                  context 'unset' do
-                    let(:command_opts) { { :max_time => nil } }
-                    it 'should not pass any options to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :max_time => 30 } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A max_time value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-
-                describe 'voice' do
-                  context 'unset' do
-                    let(:command_opts) { { :voice => nil } }
-                    it 'should not pass the v option to STREAM FILE' do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context 'set' do
-                    let(:command_opts) { { :voice => 'alison' } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'A voice value is unsupported on Asterisk.'
-                      command.response(0.1).should == error
-                    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 STREAM FILE" do
-                      expect_stream_file_with_options
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :any" do
-                    let(:command_opts) { { :interrupt_on => :any } }
-                    it "should pass all digits to STREAM FILE" do
-                      expect_stream_file_with_options '0123456789*#'
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :dtmf" do
-                    let(:command_opts) { { :interrupt_on => :dtmf } }
-                    it "should pass all digits to STREAM FILE" do
-                      expect_stream_file_with_options '0123456789*#'
-                      subject.execute
-                    end
-                  end
-
-                  context "set to :speech" do
-                    let(:command_opts) { { :interrupt_on => :speech } }
-                    it "should return an error and not execute any actions" do
-                      subject.execute
-                      error = ProtocolError.new 'option error', 'An interrupt-on value of speech is unsupported.'
-                      command.response(0.1).should == error
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end