adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/router/evented_route_spec.rb

@@ -11,7 +11,7 @@ module Adhearsion
 
       before { subject.extend described_class }
 
-      it { should be_evented }
+      it { is_expected.to be_evented }
 
       describe "dispatching a call" do
         let(:call) { Call.new }
@@ -24,7 +24,7 @@ module Adhearsion
           end
 
           it "should yield the call to the block" do
-            call.should_receive(:foo).once
+            expect(call).to receive(:foo).once
             route.dispatch call
           end
         end

data/spec/adhearsion/router/openended_route_spec.rb

@@ -11,34 +11,34 @@ module Adhearsion
 
       before { subject.extend described_class }
 
-      it { should be_openended }
+      it { is_expected.to be_openended }
 
       describe "dispatching a call" do
         let(:call) { Call.new }
 
         let(:latch) { CountDownLatch.new 1 }
 
-        before { call.wrapped_object.stub :write_and_await_response }
+        before { allow(call.wrapped_object).to 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
-            call.should_receive(:accept).once
+            expect(call).to receive(:accept).once
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
 
           it "should instruct the call to use an instance of the controller" do
-            call.should_receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
+            expect(call).to receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
             route.dispatch call
           end
 
           it "should not hangup the call after all controllers have executed" do
-            call.should_receive(:hangup).never
+            expect(call).to receive(:hangup).never
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
         end
 
@@ -50,8 +50,8 @@ module Adhearsion
           end
 
           it "should instruct the call to use a CallController with the correct block" do
-            call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
-              controller.block.call.should be == :foobar
+            expect(call).to receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)) do |controller|
+              expect(controller.block.call).to eq(:foobar)
             end
             route.dispatch call
           end

data/spec/adhearsion/router/route_spec.rb

@@ -16,25 +16,47 @@ module Adhearsion
 
         subject { Route.new name }
 
-        it { should_not be_evented }
-        it { should be_accepting }
+        it { is_expected.not_to be_evented }
+        it { is_expected.to be_accepting }
 
         describe "with a class target and guards" do
           let(:target) { CallController }
 
           subject { Route.new name, target, *guards }
 
-          its(:name)    { should be == name }
-          its(:target)  { should be == target }
-          its(:guards)  { should be == guards }
+          describe '#name' do
+            subject { super().name }
+            it { is_expected.to eq(name) }
+          end
+
+          describe '#target' do
+            subject { super().target }
+            it { is_expected.to eq(target) }
+          end
+
+          describe '#guards' do
+            subject { super().guards }
+            it { is_expected.to eq(guards) }
+          end
         end
 
         describe "with a block target and guards" do
           subject { Route.new(name, *guards) { :foo } }
 
-          its(:name)    { should be == name }
-          its(:target)  { should be_a Proc }
-          its(:guards)  { should be == guards }
+          describe '#name' do
+            subject { super().name }
+            it { is_expected.to eq(name) }
+          end
+
+          describe '#target' do
+            subject { super().target }
+            it { is_expected.to be_a Proc }
+          end
+
+          describe '#guards' do
+            subject { super().guards }
+            it { is_expected.to eq(guards) }
+          end
         end
       end
 
@@ -42,11 +64,11 @@ module Adhearsion
         subject { Route.new 'foobar', CallController, *guards }
 
         def should_match_the_call
-          subject.match?(call).should be true
+          expect(subject.match?(call)).to be true
         end
 
         def should_not_match_the_call
-          subject.match?(call).should be false
+          expect(subject.match?(call)).to be false
         end
 
         describe "matching calls from fred to paul" do
@@ -109,34 +131,42 @@ module Adhearsion
 
         let(:latch) { CountDownLatch.new 1 }
 
-        before { call.wrapped_object.stub :write_and_await_response }
+        before { allow(call.wrapped_object).to receive :write_and_await_response }
 
         context "via a call controller" do
           let(:controller)  { CallController }
           let(:route)       { Route.new 'foobar', controller }
 
           it "should immediately fire the :call_routed event giving the call and route" do
-            Adhearsion::Events.should_receive(:trigger_immediately).once.with(:call_routed, call: call, route: route)
-            call.should_receive(:hangup).once
+            expect(Adhearsion::Events).to receive(:trigger_immediately).once.with(:call_routed, call: call, route: route)
+            expect(call).to receive(:hangup).once
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
 
           it "should accept the call" do
-            call.should_receive(:accept).once
+            expect(call).to receive(:accept).once
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
 
           it "should instruct the call to use an instance of the controller" do
-            call.should_receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
+            expect(call).to receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
             route.dispatch call
           end
 
           it "should hangup the call after all controllers have executed" do
-            call.should_receive(:hangup).once
+            expect(call).to receive(:hangup).once
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
+          end
+
+          context "when the call has already ended before routing can begin" do
+            before { Celluloid::Actor.kill call }
+
+            it "should fall through cleanly" do
+              expect { route.dispatch call }.not_to raise_error
+            end
           end
 
           context "when the call has already ended before routing can begin" do
@@ -162,7 +192,7 @@ module Adhearsion
 
             it "gives the next call fresh metadata" do
               expected_controller = controller.new call, nil
-              call.should_receive(:execute_controller).once.with expected_controller, kind_of(Proc)
+              expect(call).to receive(:execute_controller).once.with expected_controller, kind_of(Proc)
               route.dispatch call
             end
           end
@@ -171,20 +201,20 @@ module Adhearsion
             before { call.auto_hangup = false }
 
             it "should not hangup the call after controller execution" do
-              call.should_receive(:hangup).never
+              expect(call).to receive(:hangup).never
               route.dispatch call, lambda { latch.countdown! }
-              latch.wait(2).should be true
+              expect(latch.wait(2)).to be true
             end
           end
 
           context "if hangup raises a Call::Hangup" do
-            before { call.should_receive(:hangup).once.and_raise Call::Hangup }
+            before { expect(call).to receive(:hangup).once.and_raise Call::Hangup }
 
             it "should not raise an exception" do
-              lambda do
+              expect do
                 route.dispatch call, lambda { latch.countdown! }
-                latch.wait(2).should be true
-              end.should_not raise_error
+                expect(latch.wait(2)).to be true
+              end.not_to raise_error
             end
           end
 
@@ -198,10 +228,10 @@ module Adhearsion
             end
 
             it "should not raise an exception" do
-              lambda do
+              expect do
                 route.dispatch call, lambda { latch.countdown! }
-                latch.wait(2).should be true
-              end.should_not raise_error
+                expect(latch.wait(2)).to be true
+              end.not_to raise_error
             end
           end
         end
@@ -214,8 +244,8 @@ module Adhearsion
           end
 
           it "should instruct the call to use a CallController with the correct block" do
-            call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
-              controller.block.call.should be == :foobar
+            expect(call).to receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)) do |controller|
+              expect(controller.block.call).to eq(:foobar)
             end
             route.dispatch call
           end

data/spec/adhearsion/router/unaccepting_route_spec.rb

@@ -11,44 +11,44 @@ module Adhearsion
 
       before { subject.extend described_class }
 
-      it { should_not be_accepting }
+      it { is_expected.not_to be_accepting }
 
       describe "dispatching a call" do
         let(:call) { Call.new }
 
         let(:latch) { CountDownLatch.new 1 }
 
-        before { call.wrapped_object.stub :write_and_await_response }
+        before { allow(call.wrapped_object).to 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
-            call.should_receive(:accept).never
+            expect(call).to receive(:accept).never
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
 
           it "should instruct the call to use an instance of the controller" do
-            call.should_receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
+            expect(call).to receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
             route.dispatch call
           end
 
           it "should hangup the call after all controllers have executed" do
-            call.should_receive(:hangup).once
+            expect(call).to receive(:hangup).once
             route.dispatch call, lambda { latch.countdown! }
-            latch.wait(2).should be true
+            expect(latch.wait(2)).to be true
           end
 
           context "if hangup raises a Call::Hangup" do
-            before { call.should_receive(:hangup).once.and_raise Call::Hangup }
+            before { expect(call).to receive(:hangup).once.and_raise Call::Hangup }
 
             it "should not raise an exception" do
-              lambda do
+              expect do
                 route.dispatch call, lambda { latch.countdown! }
-                latch.wait(2).should be true
-              end.should_not raise_error
+                expect(latch.wait(2)).to be true
+              end.not_to raise_error
             end
           end
         end
@@ -61,8 +61,8 @@ module Adhearsion
           end
 
           it "should instruct the call to use a CallController with the correct block" do
-            call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
-              controller.block.call.should be == :foobar
+            expect(call).to receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)) do |controller|
+              expect(controller.block.call).to eq(:foobar)
             end
             route.dispatch call
           end

data/spec/adhearsion/router_spec.rb

@@ -10,14 +10,14 @@ module Adhearsion
       subject { Router.new {} }
 
       let(:call) { double 'Adhearsion::Call' }
-      before { call.stub id: 'abc123' }
+      before { allow(call).to receive_messages id: 'abc123' }
 
       it "should make the router available to the block" do
         foo = nil
         Router.new do
           foo = self
         end
-        foo.should be_a Router
+        expect(foo).to be_a Router
       end
 
       describe "defining routes in the block" do
@@ -35,26 +35,28 @@ module Adhearsion
 
         subject { router.routes }
 
-        it { should have(3).elements }
+        it 'has 3 elements' do
+          expect(subject.size).to eq(3)
+        end
 
         it "should contain Routes" do
           subject.each do |route|
-            route.should be_a Router::Route
+            expect(route).to be_a Router::Route
           end
         end
 
         it "should build up the routes with the correct data" do
-          subject[0].name.should be == 'calls from fred'
-          subject[0].guards.should be == [{:from => 'fred'}]
-          subject[0].target.should be == FooBarController
+          expect(subject[0].name).to eq('calls from fred')
+          expect(subject[0].guards).to eq([{:from => 'fred'}])
+          expect(subject[0].target).to eq(FooBarController)
 
-          subject[1].name.should be == 'calls from paul'
-          subject[1].guards.should be == [{:from => 'paul'}]
-          subject[1].target.should be_a Proc
+          expect(subject[1].name).to eq('calls from paul')
+          expect(subject[1].guards).to eq([{:from => 'paul'}])
+          expect(subject[1].target).to be_a Proc
 
-          subject[2].name.should be == 'catchall'
-          subject[2].guards.should be == []
-          subject[2].target.should be_a Proc
+          expect(subject[2].name).to eq('catchall')
+          expect(subject[2].guards).to eq([])
+          expect(subject[2].target).to be_a Proc
         end
 
         context "as evented" do
@@ -70,8 +72,8 @@ module Adhearsion
           end
 
           it "should create a route which is evented" do
-            subject[0].should_not be_evented
-            subject[1].should be_evented
+            expect(subject[0]).not_to be_evented
+            expect(subject[1]).to be_evented
           end
         end
 
@@ -88,8 +90,8 @@ module Adhearsion
           end
 
           it "should create a route with is unaccepting" do
-            subject[0].should be_accepting
-            subject[1].should_not be_accepting
+            expect(subject[0]).to be_accepting
+            expect(subject[1]).not_to be_accepting
           end
         end
 
@@ -106,8 +108,8 @@ module Adhearsion
           end
 
           it "should create a route which is openended" do
-            subject[0].should_not be_openended
-            subject[1].should be_openended
+            expect(subject[0]).not_to be_openended
+            expect(subject[1]).to be_openended
           end
         end
 
@@ -126,10 +128,10 @@ module Adhearsion
           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
+            expect(subject[0]).to be_accepting
+            expect(subject[0]).not_to be_evented
+            expect(subject[1]).to be_evented
+            expect(subject[1]).not_to be_accepting
           end
         end
       end
@@ -153,18 +155,30 @@ module Adhearsion
         subject { router.match call }
 
         context 'with a call from fred' do
-          before { call.stub :from => 'fred' }
-          its(:name) { should be == 'calls from fred' }
+          before { allow(call).to receive_messages :from => 'fred' }
+
+          describe '#name' do
+            subject { super().name }
+            it { is_expected.to eq('calls from fred') }
+          end
         end
 
         context 'with a call from paul' do
-          before { call.stub :from => 'paul' }
-          its(:name) { should be == 'calls from paul' }
+          before { allow(call).to receive_messages :from => 'paul' }
+
+          describe '#name' do
+            subject { super().name }
+            it { is_expected.to eq('calls from paul') }
+          end
         end
 
         context 'with a call from frank' do
-          before { call.stub :from => 'frank' }
-          its(:name) { should be == 'catchall' }
+          before { allow(call).to receive_messages :from => 'frank' }
+
+          describe '#name' do
+            subject { super().name }
+            it { is_expected.to eq('catchall') }
+          end
         end
       end
 
@@ -178,7 +192,7 @@ module Adhearsion
         let(:route) { subject.routes.first }
 
         it "should dispatch via the route" do
-          route.should_receive(:dispatch).once.with call
+          expect(route).to receive(:dispatch).once.with call
           subject.handle call
         end
 
@@ -188,7 +202,7 @@ module Adhearsion
           end
 
           it "should return a dispatcher which rejects the call as an error" do
-            call.should_receive(:reject).once.with(:error)
+            expect(call).to receive(:reject).once.with(:error)
             subject.handle call
           end
         end
@@ -200,10 +214,10 @@ module Adhearsion
             end
           end
 
-          before { call.stub to: 'bar' }
+          before { allow(call).to receive_messages to: 'bar' }
 
           it "should return a dispatcher which rejects the call as an error" do
-            call.should_receive(:reject).once.with(:error)
+            expect(call).to receive(:reject).once.with(:error)
             subject.handle call
           end
         end