adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/call_controller/record_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    describe Record do
+      include CallControllerTestHelpers
+
+      describe "#record" do
+        let(:options) do
+          {
+            :start_beep => true,
+            :max_duration => 5000
+          }
+        end
+        let(:component) { Punchblock::Component::Record.new options }
+        let(:response)  { Punchblock::Event::Complete.new }
+
+        describe "with :async => true and an :on_complete callback" do
+          let(:callback) { lambda { |rec| @rec.push rec } }
+
+          before do
+            expect_component_execution_asynchronously component
+            @rec = Queue.new
+            options.merge! :async => true, :on_complete => callback
+            subject.record options
+            component.request!
+            component.execute!
+          end
+
+          it "should execute the callback" do
+            component.trigger_event_handler response
+            Timeout::timeout 5 do
+              @rec.pop.should == response
+            end
+          end
+
+          describe "when the callback raises an exception" do
+            before { TestException = Class.new StandardError }
+            let(:callback) { lambda { |rec| raise TestException } }
+
+            it "should pass the exception to the events system" do
+              flexmock(Events).should_receive(:trigger).once.with(:exception, TestException)
+              component.trigger_event_handler response
+            end
+          end
+        end
+
+        describe "with :async => false" do
+          before do
+            expect_component_execution component
+            component.request!
+            component.execute!
+            component.add_event response
+            @rec = Queue.new
+            subject.record(options.merge(:async => false)) { |rec| @rec.push rec }
+          end
+
+          it 'should execute a passed block' do
+            Timeout::timeout 5 do
+              @rec.pop.should == response
+            end
+          end
+        end
+      end
+
+      describe "#record with default options" do
+        let(:options) {{
+          :start_beep => true,
+          :format => 'mp3',
+          :start_paused => false,
+          :stop_beep => true,
+          :max_duration => 500000,
+          :initial_timeout => 10000,
+          :final_timeout => 30000
+        }}
+
+        let(:component) { Punchblock::Component::Record.new(options) }
+        let(:response) { Punchblock::Event::Complete.new }
+
+        before do
+          expect_message_waiting_for_response component
+          component.execute!
+          component.complete_event = response
+        end
+
+        it 'executes a #record with the correct options' do
+          subject.execute_component_and_await_completion component
+        end
+
+        it 'takes a block which is executed after acknowledgement but before waiting on completion' do
+          @comp = nil
+          subject.execute_component_and_await_completion(component) { |comp| @comp = comp }.should == component
+          @comp.should == component
+        end
+
+        describe "with a successful completion" do
+          it 'returns the executed component' do
+            subject.execute_component_and_await_completion(component).should be component
+          end
+        end
+
+        describe 'with an error response' do
+          let(:response) do
+            Punchblock::Event::Complete.new.tap do |complete|
+              complete << error
+            end
+          end
+
+          let(:error) do |error|
+            Punchblock::Event::Complete::Error.new.tap do |error|
+              error << details
+            end
+          end
+
+          let(:details) { "Something came up" }
+
+          it 'raises the error' do
+            lambda { subject.execute_component_and_await_completion component }.should raise_error(StandardError, details)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/adhearsion/call_controller_spec.rb

@@ -0,0 +1,395 @@
+require 'spec_helper'
+
+module Adhearsion
+  describe CallController do
+    include CallControllerTestHelpers
+
+    let(:call) { Adhearsion::Call.new mock_offer(nil, :x_foo => 'bar') }
+
+    its(:call)      { should be call }
+    its(:metadata)  { should == {:doo => :dah} }
+
+    describe "setting meta-data" do
+      it "should preserve data correctly" do
+        subject[:foo].should be nil
+        subject[:foo] = 7
+        subject[:foo].should == 7
+        subject[:bar] = 10
+        subject[:bar].should == 10
+        subject[:foo].should == 7
+      end
+    end
+
+    it "should add plugin dialplan methods" do
+      subject.should respond_to :foo
+    end
+
+    its(:logger)    { should be call.logger }
+    its(:variables) { should be call.variables }
+
+    describe "execution on a call" do
+      before do
+        flexmock subject, :execute_component_and_await_completion => nil
+        flexmock call, :write_and_await_response => nil
+      end
+
+      context "when auto-accept is enabled" do
+        before do
+          Adhearsion.config.platform.automatically_accept_incoming_calls = true
+        end
+
+        it "should accept the call" do
+          subject.should_receive(:accept).once.ordered
+          subject.should_receive(:run).once.ordered
+          subject.execute!
+        end
+
+        context "and accept is skipped" do
+          before { subject.skip_accept! }
+
+          it "should not accept the call" do
+            subject.should_receive(:accept).never
+            subject.should_receive(:run).once
+            subject.execute!
+          end
+        end
+      end
+
+      context "when auto-accept is disabled" do
+        before do
+          Adhearsion.config.platform.automatically_accept_incoming_calls = false
+        end
+
+        it "should not accept the call" do
+          subject.should_receive(:accept).never
+          subject.should_receive(:run).once
+          subject.execute!
+        end
+      end
+
+      it "catches Hangup exceptions and logs the hangup" do
+        subject.should_receive(:run).once.and_raise(Hangup).ordered
+        flexmock(subject.logger).should_receive(:info).once.with(/Call was hung up/).ordered
+        subject.execute!
+      end
+
+      it "catches standard errors, triggering an exception event" do
+        subject.should_receive(:run).once.and_raise(StandardError).ordered
+        flexmock(Events).should_receive(:trigger).once.with(:exception, StandardError).ordered
+        subject.execute!
+      end
+    end
+
+    class SecondController < CallController
+      def run
+        md_check metadata
+        answer
+      end
+
+      def md_check(md)
+      end
+    end
+
+    class SecondControllerWithRemoteHangup < SecondController
+      def run
+        super
+        simulate_remote_hangup
+      end
+
+      def simulate_remote_hangup
+        raise Hangup
+      end
+    end
+
+    describe "#invoke" do
+      class InvokeController < CallController
+        def run
+          before
+          invoke second_controller, :foo => 'bar'
+          after
+        end
+
+        def before
+        end
+
+        def after
+        end
+
+        def second_controller
+          metadata[:second_controller] || SecondController
+        end
+      end
+
+      subject { InvokeController.new call }
+
+      before do
+        flexmock subject, :execute_component_and_await_completion => nil
+        flexmock call, :write_and_await_response => nil
+        flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
+        Adhearsion.config.platform.automatically_accept_incoming_calls = true
+      end
+
+      it "should invoke another controller before returning to the current controller" do
+        subject.should_receive(:before).once.ordered
+        call.should_receive(:answer).once.ordered
+        subject.should_receive(:after).once.ordered
+
+        subject.execute!
+      end
+
+      it "should invoke the new controller with metadata" do
+        flexmock(SecondController).new_instances.should_receive(:md_check).once.with :foo => 'bar'
+        subject.execute!
+      end
+
+      it "should not attempt to accept the call again" do
+        call.should_receive(:accept).once
+
+        subject.execute!
+      end
+
+      it "should allow the outer controller to cease execution and handle remote hangups" do
+        subject[:second_controller] = SecondControllerWithRemoteHangup
+
+        subject.should_receive(:before).once.ordered
+        call.should_receive(:answer).once.ordered
+        subject.should_receive(:after).never.ordered
+
+        subject.execute!
+      end
+    end
+
+    describe "#pass" do
+      class PassController < CallController
+        after_call :foobar
+
+        def run
+          before
+          pass SecondController, :foo => 'bar'
+          after
+        end
+
+        def before
+        end
+
+        def after
+        end
+
+        def foobar
+        end
+      end
+
+      subject { PassController.new call }
+
+      before do
+        flexmock(call).should_receive(:write_and_await_response).and_return nil
+        flexmock subject, :execute_component_and_await_completion => nil
+        flexmock(SecondController).new_instances.should_receive(:md_check).once.with :foo => 'bar'
+        flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
+        Adhearsion.config.platform.automatically_accept_incoming_calls = true
+      end
+
+      let(:latch) { CountDownLatch.new 1 }
+
+      it "should cease execution of the current controller, and instruct the call to execute another" do
+        subject.should_receive(:before).once.ordered
+        call.should_receive(:answer).once.ordered
+        subject.should_receive(:after).never.ordered
+        call.should_receive(:hangup!).once.ordered
+
+        call.execute_controller subject, latch
+        latch.wait(1).should be_true
+      end
+
+      it "should not attempt to accept the call again" do
+        call.should_receive(:accept).once
+
+        CallController.exec subject
+      end
+
+      it "should execute after_call callbacks before passing control" do
+        subject.should_receive(:before).once.ordered
+        subject.should_receive(:foobar).once.ordered
+        call.should_receive(:answer).once.ordered
+
+        CallController.exec subject
+      end
+    end
+
+    describe '#write_and_await_response' do
+      let(:message) { Punchblock::Command::Accept.new }
+
+      it "delegates to the call" do
+        flexmock(subject.call).should_receive(:write_and_await_response).once.with(message, 20)
+        subject.write_and_await_response message, 20
+      end
+    end
+
+    describe "#execute_component_and_await_completion" do
+      let(:component) { Punchblock::Component::Output.new }
+      let(:response)  { Punchblock::Event::Complete.new }
+
+      before do
+        expect_message_waiting_for_response component
+        component.execute!
+        component.complete_event = response
+      end
+
+      it "writes component to the server and waits on response" do
+        subject.execute_component_and_await_completion component
+      end
+
+      it "takes a block which is executed after acknowledgement but before waiting on completion" do
+        @comp = nil
+        subject.execute_component_and_await_completion(component) { |comp| @comp = comp }.should == component
+        @comp.should == component
+      end
+
+      describe "with a successful completion" do
+        it "returns the executed component" do
+          subject.execute_component_and_await_completion(component).should be component
+        end
+      end
+
+      describe "with an error response" do
+        let(:response) do
+          Punchblock::Event::Complete.new.tap do |complete|
+            complete << error
+          end
+        end
+
+        let(:error) do |error|
+          Punchblock::Event::Complete::Error.new.tap do |error|
+            error << details
+          end
+        end
+
+        let(:details) { "Oh noes, it's all borked" }
+
+        it "raises the error" do
+          lambda { subject.execute_component_and_await_completion component }.should raise_error(StandardError, details)
+        end
+      end
+
+      it "blocks until the component receives a complete event" do
+        slow_component = Punchblock::Component::Output.new
+        Thread.new do
+          sleep 0.5
+          slow_component.complete_event = response
+        end
+        starting_time = Time.now
+        subject.execute_component_and_await_completion slow_component
+        (Time.now - starting_time).should > 0.5
+      end
+    end
+
+    describe '#accept' do
+      it "should delegate to the call" do
+        flexmock(subject.call).should_receive(:accept).once.with(:foo)
+        subject.accept :foo
+      end
+    end
+
+    describe '#answer' do
+      it "should delegate to the call" do
+        flexmock(subject.call).should_receive(:answer).once.with(:foo)
+        subject.answer :foo
+      end
+    end
+
+    describe '#reject' do
+      it "should delegate to the call" do
+        flexmock(subject.call).should_receive(:reject).once.with(:foo, :bar)
+        subject.reject :foo, :bar
+      end
+    end
+
+    describe '#hangup' do
+      it "should delegate to the call" do
+        flexmock(subject.call).should_receive(:hangup!).once.with(:foo)
+        subject.hangup :foo
+      end
+    end
+
+    describe '#mute' do
+      it 'should send a Mute message' do
+        expect_message_waiting_for_response Punchblock::Command::Mute.new
+        subject.mute
+      end
+    end
+
+    describe '#unmute' do
+      it 'should send an Unmute message' do
+        expect_message_waiting_for_response Punchblock::Command::Unmute.new
+        subject.unmute
+      end
+    end
+  end
+end
+
+class ExampleCallController < Adhearsion::CallController
+  before_call { setup_models }
+  before_call :setup_models
+
+  after_call { clean_up_models }
+  after_call :clean_up_models
+
+  def setup_models
+  end
+
+  def clean_up_models
+  end
+
+  def run
+    join_to_conference
+    hangup unless metadata[:skip_hangup]
+    foobar
+  end
+
+  def join_to_conference
+  end
+
+  def foobar
+  end
+end
+
+describe ExampleCallController do
+  include CallControllerTestHelpers
+
+  before do
+    flexmock subject, :execute_component_and_await_completion => nil
+    flexmock call, :write_and_await_response => nil
+    Adhearsion.config.platform.automatically_accept_incoming_calls = true
+  end
+
+  it "should execute the before_call callbacks before accepting the call" do
+    subject.should_receive(:setup_models).twice.ordered
+    subject.should_receive(:accept).once.ordered
+    subject.should_receive(:join_to_conference).once.ordered
+    subject.execute!
+  end
+
+  it "should execute the after_call callbacks after the call is hung up" do
+    subject.should_receive(:join_to_conference).once.ordered
+    subject.should_receive(:clean_up_models).twice.ordered
+    subject.should_receive(:foobar).once.ordered
+    subject.execute!
+  end
+
+  it "should capture errors in callbacks" do
+    subject.should_receive(:setup_models).and_raise StandardError
+    subject.should_receive(:clean_up_models).and_raise StandardError
+    flexmock(Adhearsion::Events).should_receive(:trigger).times(4).with :exception, StandardError
+    subject.execute!
+  end
+
+  context "when the controller finishes without a hangup" do
+    it "should execute the after_call callbacks" do
+      subject[:skip_hangup] = true
+      subject.should_receive(:join_to_conference).once.ordered
+      subject.should_receive(:foobar).once.ordered
+      subject.should_receive(:clean_up_models).twice.ordered
+      subject.execute!
+    end
+  end
+end