adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/process_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Adhearsion::Process do
+  before :each do
+    Adhearsion::Process.reset
+  end
+
+  it 'should trigger :stop_requested events on #shutdown' do
+    flexmock(Adhearsion::Events).should_receive(:trigger_immediately).once.with(:stop_requested)
+    Adhearsion::Process.booted
+    Adhearsion::Process.shutdown
+  end
+
+  it '#stop_when_zero_calls should wait until the list of active calls reaches 0' do
+    pending
+    calls = ThreadSafeArray.new
+    3.times do
+      fake_call = Object.new
+      flexmock(fake_call).should_receive(:hangup).once
+      calls << fake_call
+    end
+    flexmock(Adhearsion).should_receive(:active_calls).and_return calls
+    flexmock(Adhearsion::Process.instance).should_receive(:final_shutdown).once
+    calls = []
+    3.times { calls << Thread.new { sleep 1; calls.pop } }
+    Adhearsion::Process.stop_when_zero_calls
+    calls.each { |thread| thread.join }
+  end
+
+  it 'should terminate the process immediately on #force_stop' do
+    flexmock(::Process).should_receive(:exit).with(1).once.and_return true
+    Adhearsion::Process.force_stop
+  end
+end

data/spec/adhearsion/punchblock_plugin/initializer_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+module Adhearsion
+  class PunchblockPlugin
+    describe Initializer do
+
+      def reset_default_config
+        Adhearsion.config.punchblock do |config|
+          config.platform           = :xmpp
+          config.username           = "usera@127.0.0.1"
+          config.password           = "1"
+          config.host               = nil
+          config.port               = nil
+          config.root_domain        = nil
+          config.calls_domain       = nil
+          config.mixers_domain      = nil
+          config.connection_timeout = 60
+          config.reconnect_attempts = 1.0/0.0
+          config.reconnect_timer    = 5
+        end
+      end
+
+      def initialize_punchblock(options = {})
+        reset_default_config
+        flexmock(Initializer).should_receive(:connect)
+        Adhearsion.config.punchblock do |config|
+          config.platform           = options[:platform] if options.has_key?(:platform)
+          config.username           = options[:username] if options.has_key?(:username)
+          config.password           = options[:password] if options.has_key?(:password)
+          config.host               = options[:host] if options.has_key?(:host)
+          config.port               = options[:port] if options.has_key?(:port)
+          config.root_domain        = options[:root_domain] if options.has_key?(:root_domain)
+          config.calls_domain       = options[:calls_domain] if options.has_key?(:calls_domain)
+          config.mixers_domain      = options[:mixers_domain] if options.has_key?(:mixers_domain)
+          config.connection_timeout = options[:connection_timeout] if options.has_key?(:connection_timeout)
+          config.reconnect_attempts = options[:reconnect_attempts] if options.has_key?(:reconnect_attempts)
+          config.reconnect_timer    = options[:reconnect_timer] if options.has_key?(:reconnect_timer)
+        end
+
+        Initializer.start
+        Adhearsion.config[:punchblock]
+      end
+
+      before do
+        Events.refresh!
+      end
+
+      let(:call_id)       { rand }
+      let(:offer)         { ::Punchblock::Event::Offer.new.tap { |o| o.call_id = call_id } }
+      let(:mock_call)     { flexmock('Call', :id => call_id).tap { |call| call.should_ignore_missing } }
+      let(:mock_manager)  { flexmock 'a mock dialplan manager' }
+
+      describe "starts the client with the default values" do
+        subject { initialize_punchblock }
+
+        it "should set properly the username value" do
+          subject.username.should == 'usera@127.0.0.1'
+        end
+
+        it "should set properly the password value" do
+          subject.password.should == '1'
+        end
+
+        it "should set properly the host value" do
+          subject.host.should be_nil
+        end
+
+        it "should set properly the port value" do
+          subject.port.should be_nil
+        end
+
+        it "should set properly the root_domain value" do
+          subject.root_domain.should be_nil
+        end
+
+        it "should set properly the calls_domain value" do
+          subject.calls_domain.should be_nil
+        end
+
+        it "should set properly the mixers_domain value" do
+          subject.mixers_domain.should be_nil
+        end
+
+        it "should properly set the reconnect_attempts value" do
+          subject.reconnect_attempts.should == 1.0/0.0
+        end
+
+        it "should properly set the reconnect_timer value" do
+          subject.reconnect_timer.should == 5
+        end
+      end
+
+      it "starts the client with any overridden settings" do
+        overrides = {:username => 'userb@127.0.0.1', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com'}
+
+        flexmock(::Punchblock::Connection::XMPP).should_receive(:new).once.with(overrides).and_return do
+          flexmock 'Client', :event_handler= => true
+        end
+        initialize_punchblock overrides
+      end
+
+      describe "#connect" do
+        it 'should block until the connection is established' do
+          reset_default_config
+          mock_connection = flexmock :mock_connection
+          mock_connection.should_receive(:register_event_handler).once
+          flexmock(::Punchblock::Client).should_receive(:new).once.and_return mock_connection
+          flexmock(mock_connection).should_receive(:run).once
+          t = Thread.new { Initializer.start }
+          t.join 5
+          t.status.should == "sleep"
+          Events.trigger_immediately :punchblock, ::Punchblock::Connection::Connected.new
+          t.join
+        end
+      end
+
+      describe '#connect_to_server' do
+        let(:mock_client) { flexmock :client }
+
+        before :each do
+          Adhearsion::Process.reset
+          Initializer.config = reset_default_config
+          Initializer.config.reconnect_attempts = 1
+          flexmock(Adhearsion::Logging.get_logger(Initializer)).should_receive(:fatal).at_most.once
+          flexmock(Initializer).should_receive(:client).and_return mock_client
+        end
+
+        after :each do
+          Adhearsion::Process.reset
+        end
+
+        it 'should reset the Adhearsion process state to "booting"' do
+          Adhearsion::Process.booted
+          Adhearsion::Process.state_name.should == :running
+          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
+          expect { Initializer.connect_to_server }.should raise_error ::Punchblock::DisconnectedError
+          Adhearsion::Process.state_name.should == :booting
+        end
+
+        it 'should retry the connection the specified number of times' do
+          Initializer.config.reconnect_attempts = 3
+          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
+          expect { Initializer.connect_to_server }.should raise_error ::Punchblock::DisconnectedError
+          Initializer.attempts.should == 3
+        end
+
+        it 'should preserve a Punchblock::ProtocolError exception and give up' do
+          mock_client.should_receive(:run).and_raise ::Punchblock::ProtocolError
+          expect { Initializer.connect_to_server }.should raise_error ::Punchblock::ProtocolError
+        end
+
+        it 'should not attempt to reconnect if Adhearsion is shutting down' do
+          Adhearsion::Process.booted
+          Adhearsion::Process.shutdown
+          mock_client.should_receive(:run).and_raise ::Punchblock::DisconnectedError
+          Initializer.should_not raise_error ::Punchblock::DisconnectedError
+        end
+      end
+
+      describe 'using Asterisk' do
+        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :connection_timeout => 20, :root_domain => 'foo.com', :calls_domain => 'call.foo.com', :mixers_domain => 'mixer.foo.com'} }
+
+        it 'should start an Asterisk PB connection' do
+          flexmock(::Punchblock::Connection::Asterisk).should_receive(:new).once.with(overrides).and_return do
+            flexmock 'Client', :event_handler= => true
+          end
+          initialize_punchblock overrides.merge(:platform => :asterisk)
+        end
+      end
+
+      it 'should place events from Punchblock into the event handler' do
+        flexmock(Events.instance).should_receive(:trigger).once.with(:punchblock, offer)
+        initialize_punchblock
+        Initializer.client.handle_event offer
+      end
+
+      describe "dispatching an offer" do
+        before do
+          initialize_punchblock
+          flexmock(Adhearsion::Process).should_receive(:state_name).once.and_return process_state
+          flexmock(Adhearsion.active_calls).should_receive(:from_offer).once.and_return mock_call
+        end
+
+        context "when the Adhearsion::Process is :booting" do
+          let(:process_state) { :booting }
+
+          it 'should reject a call with cause :declined' do
+            mock_call.should_receive(:reject).once.with(:decline)
+          end
+        end
+
+        context "when when Adhearsion::Process is in :running" do
+          let(:process_state) { :running }
+
+          it "should execute the dispatcher provided by the router" do
+            controller = Class.new
+            Adhearsion.router do
+              route 'foobar', controller
+            end
+            first_route = Adhearsion.router.routes.first
+            flexmock(first_route.dispatcher).should_receive(:call).once.with mock_call
+          end
+        end
+
+        context "when when Adhearsion::Process is in :rejecting" do
+          let(:process_state) { :rejecting }
+
+          it 'should reject a call with cause :declined' do
+            mock_call.should_receive(:reject).once.with(:decline)
+          end
+        end
+
+        context "when when Adhearsion::Process is not :running, :stopping or :rejecting" do
+          let(:process_state) { :foobar }
+
+          it 'should reject a call with cause :error' do
+            mock_call.should_receive(:reject).once.with(:error)
+          end
+        end
+
+        after { Events.trigger_immediately :punchblock, offer }
+      end
+
+      describe "dispatching a component event" do
+        let(:component)   { flexmock 'ComponentNode' }
+        let(:mock_event)  { flexmock 'Event', :call_id => call_id, :source => component }
+
+        before do
+          initialize_punchblock
+        end
+
+        it "should place the event in the call's inbox" do
+          component.should_receive(:trigger_event_handler).once.with mock_event
+          Events.trigger_immediately :punchblock, mock_event
+        end
+      end
+
+      describe "dispatching a call event" do
+        let(:mock_event)  { flexmock 'Event', :call_id => call_id }
+        let(:latch)       { CountDownLatch.new 1 }
+
+        describe "with an active call" do
+          before do
+            initialize_punchblock
+            Adhearsion.active_calls << mock_call
+          end
+
+          it "should log an error" do
+            flexmock(Adhearsion::Logging.get_logger(Initializer)).should_receive(:debug).once.with("Event received for call #{call_id}: #{mock_event.inspect}")
+            Events.trigger_immediately :punchblock, mock_event
+          end
+
+          it "should place the event in the call's inbox" do
+            mock_call.should_receive(:<<).once.with(mock_event)
+            Initializer.dispatch_call_event mock_event, latch
+            latch.wait(10).should be_true
+          end
+        end
+
+        describe "with an inactive call" do
+          let(:mock_event) { flexmock 'Event', :call_id => call_id }
+
+          it "should log an error" do
+            flexmock(Adhearsion::Logging.get_logger(Initializer)).should_receive(:error).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
+            Initializer.dispatch_call_event mock_event
+          end
+        end
+      end
+
+      context "Punchblock configuration" do
+        describe "with config specified" do
+          before do
+            Adhearsion.config.punchblock do |config|
+              config.username = 'userb@127.0.0.1'
+              config.password = 'abc123'
+            end
+          end
+
+          subject do
+            Adhearsion.config[:punchblock]
+          end
+
+          it "should set properly the username value" do
+            subject.username.should == 'userb@127.0.0.1'
+          end
+
+          it "should set properly the password value" do
+            subject.password.should == 'abc123'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/router/route_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+module Adhearsion
+  class Router
+    describe Route do
+      describe 'a new route' do
+        let(:name) { 'catchall' }
+        let(:guards) do
+          [
+            {:to => /foobar/},
+            [{:from => 'fred'}, {:from => 'paul'}]
+          ]
+        end
+
+        describe "with a class target and guards" do
+          let(:target) { CallController }
+
+          subject { Route.new name, target, *guards }
+
+          its(:name)    { should == name }
+          its(:target)  { should == target }
+          its(:guards)  { should == guards }
+        end
+
+        describe "with a block target and guards" do
+          subject { Route.new(name, *guards) { :foo } }
+
+          its(:name)    { should == name }
+          its(:target)  { should be_a Proc }
+          its(:guards)  { should == guards }
+        end
+      end
+
+      describe "a guarded route" do
+        subject { Route.new 'foobar', CallController, *guards }
+
+        def should_match_the_call
+          subject.match?(call).should be true
+        end
+
+        def should_not_match_the_call
+          subject.match?(call).should be false
+        end
+
+        describe "matching calls from fred to paul" do
+          let :guards do
+            [
+              {:from => 'fred', :to => 'paul'}
+            ]
+          end
+
+          context "with a call from fred to paul" do
+            let(:call) { flexmock 'Adhearsion::Call', :from => 'fred', :to => 'paul' }
+            it { should_match_the_call }
+          end
+
+          context "with a call from fred to frank" do
+            let(:call) { flexmock 'Adhearsion::Call', :from => 'fred', :to => 'frank' }
+            it { should_not_match_the_call }
+          end
+
+          context "with a call from frank to paul" do
+            let(:call) { flexmock 'Adhearsion::Call', :from => 'frank', :to => 'paul' }
+            it { should_not_match_the_call }
+          end
+        end
+      end
+
+      describe "dispatching a call" do
+        let(:call) { Call.new }
+
+        context "via a call controller" do
+          let(:controller)  { CallController }
+          let(:route)       { Route.new 'foobar', controller }
+
+          it "should instruct the call to use an instance of the controller" do
+            flexmock(call).should_receive(:execute_controller).once.with controller
+            route.dispatcher.call call
+          end
+        end
+
+        context "via a block" do
+          let :route do
+            Route.new 'foobar' do
+              :foobar
+            end
+          end
+
+          it "should instruct the call to use an instance of DialplanController with the correct block" do
+            flexmock(call).should_receive(:execute_controller).once.with(DialplanController).and_return do |controller|
+              controller.dialplan.call.should == :foobar
+            end
+            route.dispatcher.call call
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/router_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+FooBarController = Class.new
+
+module Adhearsion
+  describe Router do
+    describe 'a new router' do
+      subject { Router.new {} }
+
+      it "should make the router available to the block" do
+        foo = nil
+        Router.new do
+          foo = self
+        end
+        foo.should be_a Router
+      end
+
+      describe "defining routes in the block" do
+        let(:router) do
+          Router.new do
+            route 'calls from fred', FooBarController, :from => 'fred'
+            route 'calls from paul', :from => 'paul' do
+              :bar
+            end
+            route 'catchall' do
+              :foo
+            end
+          end
+        end
+
+        subject { router.routes }
+
+        it { should have(3).elements }
+
+        it "should contain Routes" do
+          subject.each do |route|
+            route.should be_a Router::Route
+          end
+        end
+
+        it "should build up the routes with the correct data" do
+          subject[0].name.should == 'calls from fred'
+          subject[0].guards.should == [{:from => 'fred'}]
+          subject[0].target.should == FooBarController
+
+          subject[1].name.should == 'calls from paul'
+          subject[1].guards.should == [{:from => 'paul'}]
+          subject[1].target.should be_a Proc
+
+          subject[2].name.should == 'catchall'
+          subject[2].guards.should == []
+          subject[2].target.should be_a Proc
+        end
+      end
+
+      describe "matching a call" do
+        let(:router) do
+          Router.new do
+            route 'calls from fred', FooBarController, :from => 'fred'
+            route 'calls from fred2', :from => 'fred' do
+              :car
+            end
+            route 'calls from paul', :from => 'paul' do
+              :bar
+            end
+            route 'catchall' do
+              :foo
+            end
+          end
+        end
+
+        subject { router.match call }
+
+        context 'with a call from fred' do
+          let(:call) { flexmock 'Adhearsion::Call', :from => 'fred' }
+          its(:name) { should == 'calls from fred' }
+        end
+
+        context 'with a call from paul' do
+          let(:call) { flexmock 'Adhearsion::Call', :from => 'paul' }
+          its(:name) { should == 'calls from paul' }
+        end
+
+        context 'with a call from frank' do
+          let(:call) { flexmock 'Adhearsion::Call', :from => 'frank' }
+          its(:name) { should == 'catchall' }
+        end
+      end
+
+      describe "handling a call" do
+        subject do
+          Router.new do
+            route 'catchall', FooBarController
+          end
+        end
+
+        let(:call) { flexmock 'Adhearsion::Call', :id => 'abc123' }
+        let(:route) { subject.routes.first }
+
+        it "should return the route's dispatcher" do
+          subject.handle(call).should be route.dispatcher
+        end
+      end
+    end
+  end
+end