adhearsion 2.6.4 → 3.0.0.beta1

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

@@ -0,0 +1,256 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+          describe AGICommand do
+            include HasMockCallbackConnection
+
+            let(:channel)       { 'SIP/foo' }
+            let(:ami_client)    { double('AMI Client').as_null_object }
+            let(:translator)    { Translator::Asterisk.new ami_client, connection }
+            let(:mock_call)     { Translator::Asterisk::Call.new channel, translator, ami_client, connection }
+            let(:component_id)  { Adhearsion.new_uuid }
+
+            before { stub_uuids component_id }
+
+            let :original_command do
+              Adhearsion::Rayo::Component::Asterisk::AGI::Command.new :name => 'EXEC ANSWER'
+            end
+
+            subject { AGICommand.new original_command, mock_call }
+
+            let :response do
+              RubyAMI::Response.new
+            end
+
+            context 'initial execution' do
+              before { original_command.request! }
+
+              it 'should send the appropriate action' do
+                expect(ami_client).to receive(:send_action).once.with('AGI', 'Channel' => channel, 'Command' => 'EXEC ANSWER', 'CommandID' => component_id).and_return(response)
+                subject.execute
+              end
+
+              context 'with some parameters' do
+                let(:params) { [1000, 'foo'] }
+
+                let :original_command do
+                  Adhearsion::Rayo::Component::Asterisk::AGI::Command.new :name => 'WAIT FOR DIGIT', :params => params
+                end
+
+                it 'should send the appropriate action' do
+                  expect(ami_client).to receive(:send_action).once.with('AGI', 'Channel' => channel, 'Command' => 'WAIT FOR DIGIT "1000" "foo"', 'CommandID' => component_id).and_return(response)
+                  subject.execute
+                end
+              end
+            end
+
+            context 'when the AMI action completes' do
+              before do
+                original_command.request!
+              end
+
+              let :expected_response do
+                Adhearsion::Rayo::Ref.new uri: component_id
+              end
+
+              let :response do
+                RubyAMI::Response.new 'ActionID' => "552a9d9f-46d7-45d8-a257-06fe95f48d99",
+                  'Message' => 'Added AGI original_command to queue'
+              end
+
+              it 'should send the component node a ref with the action ID' do
+                expect(ami_client).to receive(:send_action).once.and_return response
+                subject.execute
+                expect(original_command.response(1)).to eq(expected_response)
+              end
+
+              context 'with an error' do
+                let(:message) { 'Action failed' }
+                let :response do
+                  RubyAMI::Error.new.tap { |e| e.message = message }
+                end
+
+                before { expect(ami_client).to receive(:send_action).once.and_raise response }
+
+                it 'should send the component node false' do
+                  subject.execute
+                  expect(original_command.response(1)).to be_falsey
+                end
+
+                context "which is 'No such channel'" do
+                  let(:message) { 'No such channel' }
+
+                  it "should return an :item_not_found error for the command" do
+                    subject.execute
+                    expect(original_command.response(0.5)).to eq(Adhearsion::ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{mock_call.id}", mock_call.id))
+                  end
+                end
+
+                context "which is 'Channel SIP/nosuchchannel does not exist.'" do
+                  let(:message) { 'Channel SIP/nosuchchannel does not exist.' }
+
+                  it "should return an :item_not_found error for the command" do
+                    subject.execute
+                    expect(original_command.response(0.5)).to eq(Adhearsion::ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{mock_call.id}", mock_call.id))
+                  end
+                end
+              end
+            end
+
+            describe 'when receiving an AsyncAGI event' do
+              before do
+                original_command.request!
+                original_command.execute!
+              end
+
+              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"     => 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
+                  Adhearsion::Rayo::Component::Asterisk::AGI::Command::Complete::Success.new :code    => 200,
+                                                                                       :result  => 123,
+                                                                                       :data    => 'timeout'
+                end
+
+                def should_send_complete_event
+                  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 '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
+                    Adhearsion::Rayo::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
+                    Adhearsion::Rayo::Component::Asterisk::AGI::Command.new :name => 'ASYNCAGI BREAK'
+                  end
+
+                  let(:chan_var) { nil }
+
+                  before do
+                    response = RubyAMI::Response.new 'Value' => chan_var
+                    expect(ami_client).to receive(:send_action).once.with('GetVar', 'Channel' => channel, 'Variable' => 'ADHEARSION_END_ON_ASYNCAGI_BREAK').and_return response
+                  end
+
+                  it 'should not send an end (hangup) event to the translator' do
+                    expect(translator).to receive(:handle_pb_event).once.with kind_of(Adhearsion::Event::Complete)
+                    expect(translator).to receive(:handle_pb_event).never.with kind_of(Adhearsion::Event::End)
+                    subject.handle_ami_event ami_event
+                  end
+
+                  context "when the ADHEARSION_END_ON_ASYNCAGI_BREAK channel var is set" do
+                    let(:chan_var) { 'true' }
+
+                    it 'should send an end (hungup) event to the translator' do
+                      expected_end_event = Adhearsion::Event::End.new reason: :hungup,
+                                                                      platform_code: 16,
+                                                                      target_call_id: mock_call.id
+
+                      expect(translator).to receive(:handle_pb_event).once.with kind_of(Adhearsion::Event::Complete)
+                      expect(translator).to receive(:handle_pb_event).once.with expected_end_event
+                      subject.handle_ami_event ami_event
+                    end
+
+                    context "when the AMI event has a timestamp" do
+                      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",
+                          'Timestamp'  => '1393368380.572575'
+                      end
+
+                      it "should use the AMI timestamp for the Rayo event" do
+                        expected_end_event = Adhearsion::Event::End.new reason: :hungup,
+                                                                        platform_code: 16,
+                                                                        target_call_id: mock_call.id,
+                                                                        timestamp: DateTime.new(2014, 2, 25, 22, 46, 20)
+                        expect(translator).to receive(:handle_pb_event).once.with kind_of(Adhearsion::Event::Complete)
+                        expect(translator).to receive(:handle_pb_event).once.with expected_end_event
+
+                        subject.handle_ami_event ami_event
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/translator/asterisk/component/asterisk/ami_action_spec.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        module Asterisk
+          describe AMIAction do
+            include HasMockCallbackConnection
+
+            let(:ami_client)      { double('AMI Client').as_null_object }
+            let(:mock_translator) { Translator::Asterisk.new ami_client, connection }
+
+            let :original_command do
+              Adhearsion::Rayo::Component::Asterisk::AMI::Action.new :name => 'ExtensionStatus', :params => { :context => 'default', :exten => 'idonno' }
+            end
+
+            before do
+              original_command.request!
+            end
+
+            subject { AMIAction.new original_command, mock_translator, ami_client }
+
+            context 'initial execution' do
+              let(:component_id) { Adhearsion.new_uuid }
+
+              let :expected_response do
+                Adhearsion::Rayo::Ref.new uri: component_id
+              end
+
+              before { stub_uuids component_id }
+
+              it 'should send the appropriate RubyAMI::Action and send the component node a ref' do
+                expect(ami_client).to receive(:send_action).once.with('ExtensionStatus', 'Context' => 'default', 'Exten' => 'idonno').and_return(RubyAMI::Response.new)
+                subject.execute
+                expect(original_command.response(1)).to eq(expected_response)
+              end
+            end
+
+            context 'when the AMI action completes' do
+              let :response do
+                RubyAMI::Response.new 'ActionID'  => '552a9d9f-46d7-45d8-a257-06fe95f48d99',
+                                      'Message'   => 'Channel status will follow',
+                                      'Exten'     => 'idonno',
+                                      'Context'   => 'default',
+                                      'Hint'      => '',
+                                      'Status'    => '-1'
+              end
+
+              before { response.text_body = 'Some text body' }
+
+              let :expected_complete_reason do
+                Adhearsion::Rayo::Component::Asterisk::AMI::Action::Complete::Success.new message: 'Channel status will follow', text_body: 'Some text body', headers: {'Exten' => "idonno", 'Context' => "default", 'Hint' => "", 'Status' => "-1"}
+              end
+
+              context 'for a non-causal action' do
+                it 'should send a complete event to the component node' do
+                  expect(ami_client).to receive(:send_action).once.and_return response
+                  expect(subject).to receive(:send_complete_event).once.with expected_complete_reason
+                  subject.execute
+                end
+              end
+
+              context 'for a causal action' do
+                let :original_command do
+                  Adhearsion::Rayo::Component::Asterisk::AMI::Action.new :name => 'CoreShowChannels'
+                end
+
+                let :expected_action do
+                  RubyAMI::Action.new 'CoreShowChannels'
+                end
+
+                let :event do
+                  RubyAMI::Event.new 'CoreShowChannel', 'ActionID' => "552a9d9f-46d7-45d8-a257-06fe95f48d99",
+                    'Channel'          => 'SIP/127.0.0.1-00000013',
+                    'UniqueID'         => '1287686437.19',
+                    'Context'          => 'adhearsion',
+                    'Extension'        => '23432',
+                    'Priority'         => '2',
+                    'ChannelState'     => '6',
+                    'ChannelStateDesc' => 'Up'
+                end
+
+                let :terminating_event do
+                  RubyAMI::Event.new 'CoreShowChannelsComplete', 'EventList' => 'Complete',
+                    'ListItems' => '3',
+                    'ActionID' => 'umtLtvSg-RN5n-GEay-Z786-YdiaSLNXkcYN'
+                end
+
+                let :event_node do
+                  Adhearsion::Event::Asterisk::AMI.new name: 'CoreShowChannel', component_id: subject.id, source_uri: subject.id, headers: {
+                    'Channel'          => 'SIP/127.0.0.1-00000013',
+                    'UniqueID'         => '1287686437.19',
+                    'Context'          => 'adhearsion',
+                    'Extension'        => '23432',
+                    'Priority'         => '2',
+                    'ChannelState'     => '6',
+                    'ChannelStateDesc' => 'Up'
+                  }
+                end
+
+                let :expected_complete_reason do
+                  Adhearsion::Rayo::Component::Asterisk::AMI::Action::Complete::Success.new message: 'Channel status will follow', text_body: 'Some text body', headers: {'Exten' => "idonno", 'Context' => "default", 'Hint' => "", 'Status' => "-1", 'EventList' => 'Complete', 'ListItems' => '3'}
+                end
+
+                before { expect(ami_client).to receive(:send_action).once.and_return response }
+
+                it 'should send events to the component node' do
+                  event_node
+                  original_command.register_handler :internal, Adhearsion::Event::Asterisk::AMI do |event|
+                    @event = event
+                  end
+                  response.events << event << terminating_event
+                  subject.execute
+                  expect(@event).to eq(event_node)
+                end
+
+                it 'should send a complete event to the component node' do
+                  response.events << event << terminating_event
+
+                  subject.execute
+
+                  expect(original_command.complete_event(0.5).reason).to eq(expected_complete_reason)
+                end
+              end
+
+              context 'with an error' do
+                let :error do
+                  RubyAMI::Error.new.tap { |e| e.message = 'Action failed' }
+                end
+
+                let :expected_complete_reason do
+                  Adhearsion::Event::Complete::Error.new details: 'Action failed'
+                end
+
+                it 'should send a complete event to the component node' do
+                  expect(ami_client).to receive(:send_action).once.and_raise error
+                  expected_complete_reason
+                  subject.execute
+                  expect(original_command.complete_event(0.5).reason).to eq(expected_complete_reason)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,257 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  module Translator
+    class Asterisk
+      module Component
+        describe ComposedPrompt do
+          class MockConnection
+            attr_reader :events
+
+            def initialize
+              @events = []
+            end
+
+            def handle_event(event)
+              @events << event
+            end
+          end
+
+          let(:connection)    { MockConnection.new }
+          let(:ami_client)    { double('AMI') }
+          let(:translator)    { Translator::Asterisk.new ami_client, connection }
+          let(:call)          { Translator::Asterisk::Call.new 'foo', translator, ami_client, connection }
+
+          let :ssml_doc do
+            RubySpeech::SSML.draw do
+              audio src: 'tt-monkeys'
+            end
+          end
+
+          let :dtmf_grammar do
+            RubySpeech::GRXML.draw mode: 'dtmf', root: 'digit' do
+              rule id: 'digit' do
+                one_of do
+                  item { '1' }
+                  item { '2' }
+                end
+              end
+            end
+          end
+
+          let :output_command_options do
+            { render_document: {value: ssml_doc} }
+          end
+
+          let :input_command_options do
+            {
+              mode: :dtmf,
+              grammar: {value: dtmf_grammar}
+            }
+          end
+
+          let(:command_options) { {} }
+
+          let :output_command do
+            Adhearsion::Rayo::Component::Output.new output_command_options
+          end
+
+          let :input_command do
+            Adhearsion::Rayo::Component::Input.new input_command_options
+          end
+
+          let :original_command do
+            Adhearsion::Rayo::Component::Prompt.new output_command, input_command, command_options
+          end
+
+          subject { described_class.new original_command, call }
+
+          let(:playbackstatus) { 'SUCCESS' }
+
+          before do
+            allow(call).to receive_messages answered?: true, execute_agi_command: true
+            allow(call).to receive(:channel_var).with('PLAYBACKSTATUS').and_return playbackstatus
+            original_command.request!
+          end
+
+          let (:ast13mode) { false }
+
+          def ami_event_for_dtmf(digit, position)
+            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)
+            call.process_ami_event ami_event_for_dtmf(digit, :start)
+            call.process_ami_event ami_event_for_dtmf(digit, :end)
+          end
+
+          describe '#execute' do
+            context '#barge_in' do
+              context 'true' do
+                it "should execute an output component on the call and return a ref" do
+                  expect(call).to receive(:execute_agi_command).once.with('EXEC Playback', 'tt-monkeys')
+                  subject.execute
+                  expect(original_command.response(0.1)).to be_a Adhearsion::Rayo::Ref
+                end
+
+                context "if output fails to start" do
+                  it "should return the error returned by output"
+                end
+
+                context "receiving dtmf during output" do
+                  it "should stop the output"
+
+                  it "should contribute to the input result"
+
+                  it "should return a match complete event"
+                end
+
+                context "when not receiving any DTMF input at all" do
+                  it "should not start the initial timer until output completes"
+                end
+              end
+
+              context 'false' do
+                it "should execute an output component on the call" do
+                  expect(call).to receive(:execute_agi_command).once.with('EXEC Playback', 'tt-monkeys')
+                  subject.execute
+                  expect(original_command.response(0.1)).to be_a Adhearsion::Rayo::Ref
+                end
+
+                context "if output fails to start" do
+                  let(:output_response) { Adhearsion::ProtocolError.new.setup 'unrenderable document error', 'The provided document could not be rendered. See http://adhearsion.com/docs/common_problems#unrenderable-document-error for details.' }
+
+                  let :ssml_doc do
+                    RubySpeech::SSML.draw do
+                      string "Foo Bar"
+                    end
+                  end
+
+                  it "should return the error returned by output" do
+                    subject.execute
+                    expect(original_command.response(0.1)).to eq(output_response)
+                  end
+                end
+
+                context "receiving dtmf during output" do
+                  it "should not stop the output"
+
+                  it "should not contribute to the input result"
+                end
+
+                context "receiving matching dtmf after output completes" do
+                  let :expected_nlsml do
+                    RubySpeech::NLSML.draw do
+                      interpretation confidence: 1 do
+                        instance "dtmf-1"
+                        input "1", mode: :dtmf
+                      end
+                    end
+                  end
+
+                  let :expected_event do
+                    Adhearsion::Event::Complete.new reason: expected_reason,
+                      component_id: subject.id,
+                      source_uri: subject.id,
+                      target_call_id: call.id
+                  end
+
+                  let :expected_reason do
+                    Adhearsion::Rayo::Component::Input::Complete::Match.new nlsml: expected_nlsml
+                  end
+
+                  def should_return_a_match_complete_event
+                    expected_event
+                    subject.execute
+                    expect(original_command.response(0.1)).to be_a Adhearsion::Rayo::Ref
+                    send_ami_events_for_dtmf 1
+
+                    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
+                  it "should not start the initial timer until output completes"
+                end
+              end
+            end
+          end
+
+          describe "#execute_command" do
+            context "with a command it does not understand" do
+              let(:command) { Adhearsion::Rayo::Component::Output::Pause.new }
+
+              before { command.request! }
+              it "returns a Adhearsion::ProtocolError response" do
+                subject.execute_command command
+                expect(command.response(0.1)).to be_a Adhearsion::ProtocolError
+              end
+            end
+
+            context "with a Stop command" do
+              let(:command) { Adhearsion::Rayo::Component::Stop.new }
+              let(:channel) { "SIP/1234-00000000" }
+              let :ami_event do
+                RubyAMI::Event.new 'AsyncAGI',
+                  'SubEvent'  => "Start",
+                  'Channel'   => channel,
+                  'Env'       => "agi_request%3A%20async%0Aagi_channel%3A%20SIP%2F1234-00000000%0Aagi_language%3A%20en%0Aagi_type%3A%20SIP%0Aagi_uniqueid%3A%201320835995.0%0Aagi_version%3A%201.8.4.1%0Aagi_callerid%3A%205678%0Aagi_calleridname%3A%20Jane%20Smith%0Aagi_callingpres%3A%200%0Aagi_callingani2%3A%200%0Aagi_callington%3A%200%0Aagi_callingtns%3A%200%0Aagi_dnid%3A%201000%0Aagi_rdnis%3A%20unknown%0Aagi_context%3A%20default%0Aagi_extension%3A%201000%0Aagi_priority%3A%201%0Aagi_enhanced%3A%200.0%0Aagi_accountcode%3A%20%0Aagi_threadid%3A%204366221312%0A%0A"
+              end
+
+              before do
+                command.request!
+                original_command.execute!
+              end
+
+              it "sets the command response to true" do
+                expect(call).to receive(:redirect_back).once
+                subject.execute_command command
+                expect(command.response(0.1)).to eq(true)
+              end
+
+              it "sends the correct complete event" do
+                expected_reason = Adhearsion::Event::Complete::Stop.new
+                expected_event = Adhearsion::Event::Complete.new reason: expected_reason,
+                  component_id: subject.id,
+                  source_uri: subject.id,
+                  target_call_id: call.id
+
+                expect(call).to receive(:redirect_back)
+                subject.execute_command command
+                expect(original_command).not_to be_complete
+                call.process_ami_event ami_event
+
+                sleep 0.2
+
+                expect(connection.events).to include(expected_event)
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end