adhearsion 2.0.1 → 2.1.0

data/spec/adhearsion/router/evented_route_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class Router
+    describe EventedRoute do
+      let(:name) { 'catchall' }
+
+      subject { Route.new name }
+
+      before { subject.extend described_class }
+
+      it { should be_evented }
+
+      describe "dispatching a call" do
+        let(:call) { Call.new }
+
+        context "via a block" do
+          subject :route do
+            Route.new 'foobar' do |c|
+              c.foo
+            end
+          end
+
+          it "should yield the call to the block" do
+            flexmock(call).should_receive(:foo).once
+            route.dispatch call
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/router/openended_route_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class Router
+    describe OpenendedRoute do
+      let(:name) { 'catchall' }
+
+      subject { Route.new name }
+
+      before { subject.extend described_class }
+
+      it { should be_openended }
+
+      describe "dispatching a call" do
+        let(:call) { Call.new }
+
+        let(:latch) { CountDownLatch.new 1 }
+
+        before { flexmock(call.wrapped_object).should_receive :write_and_await_response }
+
+        context "via a call controller" do
+          let(:controller)  { CallController }
+          subject(:route)   { Route.new 'foobar', controller }
+
+          it "should accept the call" do
+            flexmock(call).should_receive(:accept).once
+            route.dispatch call
+          end
+
+          it "should instruct the call to use an instance of the controller" do
+            flexmock(call).should_receive(:execute_controller).once.with controller, Proc
+            route.dispatch call
+          end
+
+          it "should not hangup the call after all controllers have executed" do
+            flexmock(call).should_receive(:hangup).never
+            route.dispatch call, lambda { latch.countdown! }
+            latch.wait(2).should be true
+          end
+        end
+
+        context "via a block" do
+          let :route do
+            Route.new 'foobar' do
+              :foobar
+            end
+          end
+
+          it "should instruct the call to use a CallController with the correct block" do
+            flexmock(call).should_receive(:execute_controller).once.with(CallController, Proc).and_return do |controller|
+              controller.block.call.should be == :foobar
+            end
+            route.dispatch call
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/router/route_spec.rb

@@ -14,6 +14,11 @@ module Adhearsion
           ]
         end
 
+        subject { Route.new name }
+
+        it { should_not be_evented }
+        it { should be_accepting }
+
         describe "with a class target and guards" do
           let(:target) { CallController }
 
@@ -104,27 +109,44 @@ module Adhearsion
 
         let(:latch) { CountDownLatch.new 1 }
 
+        before { flexmock(call.wrapped_object).should_receive :write_and_await_response }
+
         context "via a call controller" do
           let(:controller)  { CallController }
           let(:route)       { Route.new 'foobar', controller }
 
+          it "should accept the call" do
+            flexmock(call).should_receive(:accept).once
+            route.dispatch call
+          end
+
           it "should instruct the call to use an instance of the controller" do
             flexmock(call).should_receive(:execute_controller).once.with controller, Proc
-            route.dispatcher.call call
+            route.dispatch call
           end
 
           it "should hangup the call after all controllers have executed" do
             flexmock(call).should_receive(:hangup).once
-            route.dispatcher.call call, lambda { latch.countdown! }
+            route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
 
+          context 'with the :ahn_prevent_hangup call variable set' do
+            before { call[:ahn_prevent_hangup] = true }
+
+            it "should not hangup the call after controller execution" do
+              flexmock(call).should_receive(:hangup).never
+              route.dispatch call, lambda { latch.countdown! }
+              latch.wait(2).should be true
+            end
+          end
+
           context "if hangup raises a Call::Hangup" do
             before { flexmock(call).should_receive(:hangup).once.and_raise Call::Hangup }
 
             it "should not raise an exception" do
               lambda do
-                route.dispatcher.call call, lambda { latch.countdown! }
+                route.dispatch call, lambda { latch.countdown! }
                 latch.wait(2).should be true
               end.should_not raise_error
             end
@@ -142,7 +164,7 @@ module Adhearsion
             flexmock(call).should_receive(:execute_controller).once.with(CallController, Proc).and_return do |controller|
               controller.block.call.should be == :foobar
             end
-            route.dispatcher.call call
+            route.dispatch call
           end
         end
       end

data/spec/adhearsion/router/unaccepting_route_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class Router
+    describe UnacceptingRoute do
+      let(:name) { 'catchall' }
+
+      subject { Route.new name }
+
+      before { subject.extend described_class }
+
+      it { should_not be_accepting }
+
+      describe "dispatching a call" do
+        let(:call) { Call.new }
+
+        let(:latch) { CountDownLatch.new 1 }
+
+        before { flexmock(call.wrapped_object).should_receive :write_and_await_response }
+
+        context "via a call controller" do
+          let(:controller)  { CallController }
+          subject(:route)   { Route.new 'foobar', controller }
+
+          it "should not accept the call" do
+            flexmock(call).should_receive(:accept).never
+            route.dispatch call
+          end
+
+          it "should instruct the call to use an instance of the controller" do
+            flexmock(call).should_receive(:execute_controller).once.with controller, Proc
+            route.dispatch call
+          end
+
+          it "should hangup the call after all controllers have executed" do
+            flexmock(call).should_receive(:hangup).once
+            route.dispatch call, lambda { latch.countdown! }
+            latch.wait(2).should be true
+          end
+
+          context "if hangup raises a Call::Hangup" do
+            before { flexmock(call).should_receive(:hangup).once.and_raise Call::Hangup }
+
+            it "should not raise an exception" do
+              lambda do
+                route.dispatch call, lambda { latch.countdown! }
+                latch.wait(2).should be true
+              end.should_not raise_error
+            end
+          end
+        end
+
+        context "via a block" do
+          let :route do
+            Route.new 'foobar' do
+              :foobar
+            end
+          end
+
+          it "should instruct the call to use a CallController with the correct block" do
+            flexmock(call).should_receive(:execute_controller).once.with(CallController, Proc).and_return do |controller|
+              controller.block.call.should be == :foobar
+            end
+            route.dispatch call
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/router_spec.rb

@@ -53,6 +53,82 @@ module Adhearsion
           subject[2].guards.should be == []
           subject[2].target.should be_a Proc
         end
+
+        context "as evented" do
+          let(:router) do
+            Router.new do
+              route 'calls from fred', FooBarController, :from => 'fred'
+              evented do
+                route 'catchall' do |call|
+                  :foo
+                end
+              end
+            end
+          end
+
+          it "should create a route which is evented" do
+            subject[0].should_not be_evented
+            subject[1].should be_evented
+          end
+        end
+
+        context "as unaccepting" do
+          let(:router) do
+            Router.new do
+              route 'calls from fred', FooBarController, :from => 'fred'
+              unaccepting do
+                route 'catchall' do |call|
+                  :foo
+                end
+              end
+            end
+          end
+
+          it "should create a route with is unaccepting" do
+            subject[0].should be_accepting
+            subject[1].should_not be_accepting
+          end
+        end
+
+        context "as openended" do
+          let(:router) do
+            Router.new do
+              route 'calls from fred', FooBarController, :from => 'fred'
+              openended do
+                route 'catchall' do |call|
+                  :foo
+                end
+              end
+            end
+          end
+
+          it "should create a route which is openended" do
+            subject[0].should_not be_openended
+            subject[1].should be_openended
+          end
+        end
+
+        context "as combined evented/unaccepting" do
+          let(:router) do
+            Router.new do
+              route 'calls from fred', FooBarController, :from => 'fred'
+              unaccepting do
+                evented do
+                  route 'catchall' do |call|
+                    :foo
+                  end
+                end
+              end
+            end
+          end
+
+          it "should create a route which is evented and unaccepting" do
+            subject[0].should be_accepting
+            subject[0].should_not be_evented
+            subject[1].should be_evented
+            subject[1].should_not be_accepting
+          end
+        end
       end
 
       describe "matching a call" do
@@ -99,8 +175,37 @@ module Adhearsion
         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
+        it "should dispatch via the route" do
+          flexmock(route).should_receive(:dispatch).once.with call
+          subject.handle call
+        end
+
+        context "when there are no routes" do
+          subject do
+            Router.new {}
+          end
+
+          let(:call) { flexmock 'Adhearsion::Call', :id => 'abc123' }
+
+          it "should return a dispatcher which rejects the call as an error" do
+            call.should_receive(:reject).once.with(:error)
+            subject.handle call
+          end
+        end
+
+        context "when no routes match" do
+          subject do
+            Router.new do
+              route 'too-specific', FooBarController, :to => 'foo'
+            end
+          end
+
+          let(:call) { flexmock 'Adhearsion::Call', :id => 'abc123', :to => 'bar' }
+
+          it "should return a dispatcher which rejects the call as an error" do
+            call.should_receive(:reject).once.with(:error)
+            subject.handle call
+          end
         end
       end
     end

data/spec/adhearsion_spec.rb

@@ -3,6 +3,25 @@
 require 'spec_helper'
 
 describe Adhearsion do
+  describe "#root=" do
+    it "should update properly the config root variable" do
+      Adhearsion.root = "./"
+      Adhearsion.config[:platform].root.should be == Dir.getwd
+    end
+
+    it "should update properly the config root variable when path is nil" do
+      Adhearsion.root = nil
+      Adhearsion.config[:platform].root.should be_nil
+    end
+  end
+  
+  describe "#root" do
+    it "should return the set root" do
+      Adhearsion.root = "./"
+      Adhearsion.root.should be == Dir.getwd
+    end
+  end
+
   describe "#ahn_root=" do
     it "should update properly the config root variable" do
       Adhearsion.ahn_root = "./"

data/spec/capture_warnings.rb

@@ -1,33 +1,40 @@
 # encoding: utf-8
 
 require 'tempfile'
-stderr_file = Tempfile.new "ahn.stderr"
+stderr_file = Tempfile.new "ahn#{rand}.stderr"
+warnings_filename = "tmp/ahnwarnings#{rand}.txt"
 $stderr.reopen stderr_file.path
 current_dir = Dir.pwd
 
 at_exit do
-  stderr_file.rewind
-  lines = stderr_file.read.split("\n").uniq
-  stderr_file.close!
+  begin
+    stderr_file.rewind
+    lines = stderr_file.read.split("\n").uniq
+    stderr_file.close!
 
-  ahn_warnings, other_warnings = lines.partition { |line| line.include?(current_dir) && !line.include?('vendor') && line.include?('warning') }
+    ahn_warnings, other_warnings = lines.partition { |line| line.include?(current_dir) && !line.include?('vendor') && line.include?('warning') }
 
-  if ahn_warnings.any?
-    puts
-    puts "-" * 30 + " AHN Warnings: " + "-" * 30
-    puts
-    puts ahn_warnings.join("\n")
-    puts
-    puts "-" * 75
-    puts
-  end
+    if ahn_warnings.any?
+      puts
+      puts "-" * 30 + " AHN Warnings: " + "-" * 30
+      puts
+      puts ahn_warnings.join("\n")
+      puts
+      puts "-" * 75
+      puts
+    end
 
-  if other_warnings.any?
-    File.open('tmp/warnings.txt', 'w') { |f| f.write other_warnings.join("\n") }
-    puts
-    puts "Non-AHN warnings written to tmp/warnings.txt"
-    puts
-  end
+    if other_warnings.any?
+      File.open(warnings_filename, 'w') { |f| f.write other_warnings.join("\n") }
+      puts
+      puts "Non-AHN warnings written to #{warnings_filename}"
+      puts
+    end
 
-  exit 1 if ahn_warnings.any? # fail the build...
+    exit 1 if ahn_warnings.any? # fail the build...
+  rescue => e
+    puts "Warning capture failed."
+    puts e.message
+    puts e.backtrace.join("\n")
+  end
 end