adhearsion 2.3.0 → 2.3.1

data/spec/adhearsion/plugin_spec.rb

@@ -11,6 +11,10 @@ describe Adhearsion::Plugin do
     defined?(FooBar) and Object.send(:remove_const, :"FooBar")
   end
 
+  before do
+    Adhearsion::PunchblockPlugin::Initializer.stub :start => true
+  end
+
   describe "inheritance" do
     after do
       defined?(FooBar) and Object.send(:remove_const, :"FooBar")
@@ -139,7 +143,6 @@ describe Adhearsion::Plugin do
 
         # 1 => Punchblock. Must be empty once punchblock initializer is an external Plugin
         Adhearsion::Plugin.initializers.should have(1).initializers
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
         Adhearsion::Plugin.init_plugins
       end
 
@@ -152,9 +155,8 @@ describe Adhearsion::Plugin do
           end
         end
 
-        flexmock(FooBar).should_receive(:log).once
+        FooBar.should_receive(:log).once
         Adhearsion::Plugin.initializers.length.should be 1
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
         Adhearsion::Plugin.init_plugins
       end
 
@@ -179,8 +181,7 @@ describe Adhearsion::Plugin do
           end
         end
 
-        flexmock(FooBar).should_receive(:log).times(3)
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        FooBar.should_receive(:log).exactly(3).times
         Adhearsion::Plugin.init_plugins
       end
 
@@ -238,7 +239,6 @@ describe Adhearsion::Plugin do
 
         # May become 1 if Punchblock defines a runner.
         Adhearsion::Plugin.runners.should have(0).runners
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
         Adhearsion::Plugin.run_plugins
       end
 
@@ -251,9 +251,8 @@ describe Adhearsion::Plugin do
           end
         end
 
-        flexmock(FooBar).should_receive(:log).once
+        FooBar.should_receive(:log).once
         Adhearsion::Plugin.runners.length.should be 1
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
         Adhearsion::Plugin.run_plugins
       end
 
@@ -278,8 +277,7 @@ describe Adhearsion::Plugin do
           end
         end
 
-        flexmock(FooBar).should_receive(:log).times(3)
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        FooBar.should_receive(:log).exactly(3).times
         Adhearsion::Plugin.run_plugins
       end
 
@@ -375,7 +373,7 @@ describe Adhearsion::Plugin do
         def self.foo
         end
       end
-      flexmock(FooBar).should_receive(:foo).once
+      FooBar.should_receive(:foo).once
       Adhearsion::Plugin.load_tasks
     end
 

data/spec/adhearsion/process_spec.rb

@@ -13,8 +13,8 @@ module Adhearsion
     end
 
     it 'should trigger :stop_requested events on #shutdown' do
-      flexmock(Events).should_receive(:trigger_immediately).once.with(:stop_requested).ordered
-      flexmock(Events).should_receive(:trigger_immediately).once.with(:shutdown).ordered
+      Events.should_receive(:trigger_immediately).once.with(:stop_requested).ordered
+      Events.should_receive(:trigger_immediately).once.with(:shutdown).ordered
       Adhearsion::Process.booted
       Adhearsion::Process.shutdown
       sleep 0.2
@@ -25,11 +25,11 @@ module Adhearsion
       calls = ThreadSafeArray.new
       3.times do
         fake_call = Object.new
-        flexmock(fake_call).should_receive(:hangup).once
+        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
+      Adhearsion.should_receive(:active_calls).and_return calls
+      Adhearsion::Process.instance.should_receive(:final_shutdown).once
       calls = []
       3.times do
         calls << Thread.new do
@@ -42,15 +42,16 @@ module Adhearsion
     end
 
     it 'should terminate the process immediately on #force_stop' do
-      flexmock(::Process).should_receive(:exit).with(1).once.and_return true
+      ::Process.should_receive(:exit).with(1).once.and_return true
       Adhearsion::Process.force_stop
     end
 
     describe "#final_shutdown" do
       it "should hang up active calls" do
         3.times do
-          fake_call = flexmock Call.new, :id => random_call_id
-          flexmock(fake_call).should_receive(:hangup).once
+          fake_call = Call.new
+          fake_call.stub :id => random_call_id
+          fake_call.should_receive(:hangup).once
           Adhearsion.active_calls << fake_call
         end
 
@@ -62,9 +63,9 @@ module Adhearsion
       it "should trigger shutdown handlers synchronously" do
         foo = lambda { |b| b }
 
-        flexmock(foo).should_receive(:[]).once.with(:a).ordered
-        flexmock(foo).should_receive(:[]).once.with(:b).ordered
-        flexmock(foo).should_receive(:[]).once.with(:c).ordered
+        foo.should_receive(:[]).once.with(:a).ordered
+        foo.should_receive(:[]).once.with(:b).ordered
+        foo.should_receive(:[]).once.with(:c).ordered
 
         Events.shutdown { sleep 2; foo[:a] }
         Events.shutdown { sleep 1; foo[:b] }
@@ -74,7 +75,7 @@ module Adhearsion
       end
 
       it "should stop the console" do
-        flexmock(Console).should_receive(:stop).once
+        Console.should_receive(:stop).once
         Adhearsion::Process.final_shutdown
       end
     end
@@ -88,13 +89,13 @@ module Adhearsion
       Adhearsion::Process.state_name.should be :rejecting
       Adhearsion::Process.shutdown
       Adhearsion::Process.state_name.should be :stopped
-      flexmock(Adhearsion::Process.instance).should_receive(:die_now!).once
+      Adhearsion::Process.instance.should_receive(:die_now!).once
       Adhearsion::Process.shutdown
       sleep 0.2
     end
 
     it 'should forcibly kill the Adhearsion process on :force_stop' do
-      flexmock(::Process).should_receive(:exit).once.with(1)
+      ::Process.should_receive(:exit).once.with(1)
       Adhearsion::Process.force_stop
     end
   end

data/spec/adhearsion/punchblock_plugin/initializer_spec.rb

@@ -26,7 +26,7 @@ module Adhearsion
 
       def initialize_punchblock(options = {})
         reset_default_config
-        flexmock(Initializer).should_receive(:connect)
+        Initializer.stub(:connect)
         Adhearsion.config.punchblock do |config|
           config.platform           = options[:platform] if options.has_key?(:platform)
           config.username           = options[:username] if options.has_key?(:username)
@@ -47,16 +47,19 @@ module Adhearsion
         Adhearsion.config[:punchblock]
       end
 
+      let(:call_id)     { rand }
+      let(:offer)       { Punchblock::Event::Offer.new :target_call_id => call_id }
+      let(:mock_call)   { Call.new }
+      let(:mock_client) { mock 'Client' }
+
       before do
+        mock_call.stub :id => call_id
+        mock_client.stub :event_handler= => true
         Events.refresh!
-        flexmock Adhearsion::Process, :fqdn => 'hostname'
-        flexmock ::Process, :pid => 1234
+        Adhearsion::Process.stub :fqdn => 'hostname'
+        ::Process.stub :pid => 1234
       end
 
-      let(:call_id)   { rand }
-      let(:offer)     { Punchblock::Event::Offer.new :target_call_id => call_id }
-      let(:mock_call) { flexmock Call.new, :id => call_id }
-
       describe "starts the client with the default values" do
         subject { initialize_punchblock }
 
@@ -108,28 +111,24 @@ module Adhearsion
       it "starts the client with the correct resource" do
         username = "usera@127.0.0.1/hostname-1234"
 
-        flexmock(Punchblock::Connection::XMPP).should_receive(:new).once.with(FlexMock.hsh :username => username).and_return do
-          flexmock 'Client', :event_handler= => true
-        end
+        Punchblock::Connection::XMPP.should_receive(:new).once.with(hash_including :username => username).and_return mock_client
         initialize_punchblock
       end
 
       it "starts the client with any overridden settings" do
         overrides = {:username => 'userb@127.0.0.1/foo', :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', :media_engine => :swift, :default_voice => :hal}
 
-        flexmock(Punchblock::Connection::XMPP).should_receive(:new).once.with(overrides).and_return do
-          flexmock 'Client', :event_handler= => true
-        end
+        Punchblock::Connection::XMPP.should_receive(:new).once.with(overrides).and_return mock_client
         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 = mock :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
+          Punchblock::Client.should_receive(:new).once.and_return mock_connection
+          mock_connection.should_receive(:run).once
           t = Thread.new { Initializer.init; Initializer.run }
           t.join 5
           t.status.should be == "sleep"
@@ -139,14 +138,12 @@ module Adhearsion
       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
+          Adhearsion::Logging.get_logger(Initializer).should_receive(:fatal).at_most(:once)
+          Initializer.stub(:client).and_return mock_client
         end
 
         after :each do
@@ -156,27 +153,27 @@ module Adhearsion
         it 'should reset the Adhearsion process state to "booting"' do
           Adhearsion::Process.booted
           Adhearsion::Process.state_name.should be == :running
-          mock_client.should_receive(:run).and_raise Punchblock::DisconnectedError
-          flexmock(Adhearsion::Process).should_receive(:reset).at_least.once
+          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
+          Adhearsion::Process.should_receive(:reset).at_least(:once)
           Initializer.connect_to_server
         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
+          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
           Initializer.connect_to_server
           Initializer.attempts.should be == 3
         end
 
         it 'should preserve a Punchblock::ProtocolError exception and give up' do
-          mock_client.should_receive(:run).and_raise Punchblock::ProtocolError
+          mock_client.stub(:run).and_raise Punchblock::ProtocolError
           expect { Initializer.connect_to_server }.to 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
+          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
           Initializer.should_not raise_error Punchblock::DisconnectedError
         end
       end
@@ -185,9 +182,7 @@ module Adhearsion
         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', :media_engine => :swift, :default_voice => :hal} }
 
         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
+          Punchblock::Connection::Asterisk.should_receive(:new).once.with(overrides).and_return mock_client
           initialize_punchblock overrides.merge(:platform => :asterisk)
         end
       end
@@ -196,15 +191,13 @@ module Adhearsion
         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', :media_engine => :swift, :default_voice => :hal} }
 
         it 'should start an Asterisk PB connection' do
-          flexmock(Punchblock::Connection::Freeswitch).should_receive(:new).once.with(overrides).and_return do
-            flexmock 'Client', :event_handler= => true
-          end
+          Punchblock::Connection::Freeswitch.should_receive(:new).once.with(overrides).and_return mock_client
           initialize_punchblock overrides.merge(:platform => :freeswitch)
         end
       end
 
       it 'should place events from Punchblock into the event handler' do
-        flexmock(Events.instance).should_receive(:trigger).once.with(:punchblock, offer)
+        Events.instance.should_receive(:trigger).once.with(:punchblock, offer)
         initialize_punchblock
         Initializer.client.handle_event offer
       end
@@ -212,8 +205,8 @@ module Adhearsion
       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
+          Adhearsion::Process.should_receive(:state_name).once.and_return process_state
+          Adhearsion.active_calls.should_receive(:from_offer).once.and_return mock_call
         end
 
         context "when the Adhearsion::Process is :booting" do
@@ -232,7 +225,7 @@ module Adhearsion
               Adhearsion.router do
                 route 'foobar', Class.new
               end
-              flexmock(Adhearsion.router).should_receive(:handle).once.with mock_call
+              Adhearsion.router.should_receive(:handle).once.with mock_call
             end
           end
         end
@@ -257,8 +250,10 @@ module Adhearsion
       end
 
       describe "dispatching a component event" do
-        let(:component)   { flexmock 'ComponentNode' }
-        let(:mock_event)  { flexmock 'Event', :target_call_id => call_id, :source => component }
+        let(:component)   { mock 'ComponentNode' }
+        let(:mock_event)  { mock 'Event' }
+
+        before { mock_event.stub target_call_id: call_id, source: component }
 
         before do
           initialize_punchblock
@@ -271,7 +266,9 @@ module Adhearsion
       end
 
       describe "dispatching a call event" do
-        let(:mock_event)  { flexmock 'Event', :target_call_id => call_id }
+        let(:mock_event)  { mock 'Event' }
+
+        before { mock_event.stub target_call_id: call_id }
 
         describe "with an active call" do
           before do
@@ -280,16 +277,14 @@ module Adhearsion
           end
 
           it "should place the event in the call's inbox" do
-            mock_call.should_receive(:deliver_message!).once.with(mock_event)
+            mock_call.async.should_receive(:deliver_message).once.with(mock_event)
             Initializer.dispatch_call_event mock_event
           end
         end
 
         describe "with an inactive call" do
-          let(:mock_event) { flexmock 'Event', :target_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}")
+            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

data/spec/adhearsion/punchblock_plugin_spec.rb

@@ -13,13 +13,13 @@ module Adhearsion
     describe '#execute_component' do
       let(:message)     { Punchblock::Command::Accept.new }
       let(:response)    { :foo }
-      let(:mock_client) { flexmock 'Client' }
+      let(:mock_client) { mock 'Client' }
 
       let(:execute_expectation) { PunchblockPlugin.client.should_receive(:execute_command).once }
 
       before do
         PunchblockPlugin::Initializer.client = mock_client
-        flexmock message, :execute! => true
+        message.stub :execute! => true
         message.response = response
         execute_expectation
       end

data/spec/adhearsion/router/evented_route_spec.rb

@@ -24,7 +24,7 @@ module Adhearsion
           end
 
           it "should yield the call to the block" do
-            flexmock(call).should_receive(:foo).once
+            call.should_receive(:foo).once
             route.dispatch call
           end
         end

data/spec/adhearsion/router/openended_route_spec.rb

@@ -18,25 +18,25 @@ module Adhearsion
 
         let(:latch) { CountDownLatch.new 1 }
 
-        before { flexmock(call.wrapped_object).should_receive :write_and_await_response }
+        before { call.wrapped_object.stub :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
+            call.should_receive(:accept).once
             route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
 
           it "should instruct the call to use an instance of the controller" do
-            flexmock(call).should_receive(:execute_controller).once.with controller, Proc
+            call.should_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
-            flexmock(call).should_receive(:hangup).never
+            call.should_receive(:hangup).never
             route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
@@ -50,7 +50,7 @@ module Adhearsion
           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|
+            call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
               controller.block.call.should be == :foobar
             end
             route.dispatch call

data/spec/adhearsion/router/route_spec.rb

@@ -109,32 +109,32 @@ module Adhearsion
 
         let(:latch) { CountDownLatch.new 1 }
 
-        before { flexmock(call.wrapped_object).should_receive :write_and_await_response }
+        before { 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 immediately fire the :call_routed event giving the call and route" do
-            flexmock(Adhearsion::Events).should_receive(:trigger_immediately).once.with(:call_routed, call: call, route: route)
-            flexmock(call).should_receive(:hangup).once
+            Adhearsion::Events.should_receive(:trigger_immediately).once.with(:call_routed, call: call, route: route)
+            call.should_receive(:hangup).once
             route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
 
           it "should accept the call" do
-            flexmock(call).should_receive(:accept).once
+            call.should_receive(:accept).once
             route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
 
           it "should instruct the call to use an instance of the controller" do
-            flexmock(call).should_receive(:execute_controller).once.with controller, Proc
+            call.should_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
-            flexmock(call).should_receive(:hangup).once
+            call.should_receive(:hangup).once
             route.dispatch call, lambda { latch.countdown! }
             latch.wait(2).should be true
           end
@@ -143,14 +143,14 @@ module Adhearsion
             before { call[:ahn_prevent_hangup] = true }
 
             it "should not hangup the call after controller execution" do
-              flexmock(call).should_receive(:hangup).never
+              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 }
+            before { call.should_receive(:hangup).once.and_raise Call::Hangup }
 
             it "should not raise an exception" do
               lambda do
@@ -169,7 +169,7 @@ module Adhearsion
           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|
+            call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
               controller.block.call.should be == :foobar
             end
             route.dispatch call