adhearsion 2.3.0 → 2.3.1

data/spec/adhearsion/calls_spec.rb

@@ -125,8 +125,8 @@ module Adhearsion
 
       it "is sends a hangup command for the call" do
         call_id = call.id
-        flexmock PunchblockPlugin, :client => flexmock('Client')
-        flexmock(PunchblockPlugin.client).should_receive(:execute_command).once.with(Punchblock::Command::Hangup.new, :async => true, :call_id => call_id)
+        PunchblockPlugin.stub :client => mock('Client')
+        PunchblockPlugin.client.should_receive(:execute_command).once.with(Punchblock::Command::Hangup.new, :async => true, :call_id => call_id)
 
         subject << call
 

data/spec/adhearsion/console_spec.rb

@@ -5,10 +5,9 @@ require 'spec_helper'
 module Adhearsion
   describe Console do
     before do
-      flexmock Console.instance, :pry => nil
+      Console.instance.stub :pry => nil
     end
 
-    include FlexMock::ArgumentTypes
     describe "providing hooks to include console functionality" do
       it "should allow mixing in a module globally on all CallController classes" do
         Console.mixin TestBiscuit
@@ -18,12 +17,12 @@ module Adhearsion
 
     describe 'testing for libedit vs. readline' do
       it 'should return true when detecting readline' do
-        flexmock(Readline).should_receive(:emacs_editing_mode).once.and_return true
+        Readline.should_receive(:emacs_editing_mode).once.and_return true
         Console.libedit?.should be false
       end
 
       it 'should return false when detecting libedit' do
-        flexmock(Readline).should_receive(:emacs_editing_mode).once.and_raise NotImplementedError
+        Readline.should_receive(:emacs_editing_mode).once.and_raise NotImplementedError
         Console.libedit?.should be true
       end
     end
@@ -31,7 +30,7 @@ module Adhearsion
     describe "#log_level" do
       context "with a value" do
         it "should set the log level via Adhearsion::Logging" do
-          flexmock(Adhearsion::Logging).should_receive(:level=).once.with(:foo)
+          Adhearsion::Logging.should_receive(:level=).once.with(:foo)
           Console.log_level :foo
         end
       end
@@ -46,21 +45,21 @@ module Adhearsion
 
     describe "#silence!" do
       it "should delegate to Adhearsion::Logging" do
-        flexmock(Adhearsion::Logging).should_receive(:silence!).once
+        Adhearsion::Logging.should_receive(:silence!).once
         Console.silence!
       end
     end
 
     describe "#unsilence!" do
       it "should delegate to Adhearsion::Logging" do
-        flexmock(Adhearsion::Logging).should_receive(:unsilence!).once
+        Adhearsion::Logging.should_receive(:unsilence!).once
         Console.unsilence!
       end
     end
 
     describe "#shutdown!" do
       it "should tell the process to shutdown" do
-        flexmock(Adhearsion::Process).should_receive(:shutdown!).once
+        Adhearsion::Process.should_receive(:shutdown!).once
         Console.shutdown!
       end
     end
@@ -71,12 +70,12 @@ module Adhearsion
 
       before do
         Adhearsion.active_calls.clear!
-        flexmock(call).should_receive(:id => call_id)
+        call.stub(:id => call_id)
       end
 
       context "with a call" do
         it "should interact with the call" do
-          flexmock(Console.instance).should_receive(:interact_with_call).once.with call
+          Console.instance.should_receive(:interact_with_call).once.with call
           Console.take call
         end
       end
@@ -88,7 +87,7 @@ module Adhearsion
           end
 
           it "should interact with the current call" do
-            flexmock(Console.instance).should_receive(:interact_with_call).once.with call
+            Console.instance.should_receive(:interact_with_call).once.with call
             Console.take
           end
         end
@@ -97,15 +96,15 @@ module Adhearsion
           let(:call2) { Call.new }
 
           before do
-            flexmock(call2).should_receive :id => rand.to_s
+            call2.stub :id => rand.to_s
             Adhearsion.active_calls << call << call2
           end
 
           it "should allow selection of the call to use" do
             mock_io = StringIO.new
             Console.input = mock_io
-            flexmock(mock_io).should_receive(:gets).once.and_return "1\n"
-            flexmock(Console.instance).should_receive(:interact_with_call).once.with call2
+            mock_io.should_receive(:gets).once.and_return "1\n"
+            Console.instance.should_receive(:interact_with_call).once.with call2
             Console.take
           end
         end
@@ -118,15 +117,15 @@ module Adhearsion
           end
 
           it "should interact with that call" do
-            flexmock(Console.instance).should_receive(:interact_with_call).once.with call
+            Console.instance.should_receive(:interact_with_call).once.with call
             Console.take call_id
           end
         end
 
         context "if an active call with that ID does not exist" do
           it "should log an error explaining that the call does not exist" do
-            flexmock(Console.logger).should_receive(:error).once.with(/does not exist/)
-            flexmock(Console.instance).should_receive(:interact_with_call).never
+            Console.logger.should_receive(:error).once.with(/does not exist/)
+            Console.instance.should_receive(:interact_with_call).never
             Console.take call_id
           end
         end
@@ -137,19 +136,19 @@ module Adhearsion
       let(:call) { Call.new }
 
       it "should pause the call's controllers, and unpause even if the interactive controller raises" do
-        flexmock(call).should_receive(:pause_controllers).once.ordered
-        flexmock(CallController).should_receive(:exec).once.ordered.and_raise StandardError
-        flexmock(call).should_receive(:resume_controllers).once.ordered
+        call.should_receive(:pause_controllers).once.ordered
+        CallController.should_receive(:exec).once.ordered.and_raise StandardError
+        call.should_receive(:resume_controllers).once.ordered
         lambda { Console.interact_with_call call }.should raise_error StandardError
       end
 
       it "should execute an interactive call controller on the call" do
-        flexmock(CallController).should_receive(:exec).once.with(on do |c|
+        CallController.should_receive(:exec).once do |c|
           c.should be_a Console::InteractiveController
           c.call.should be call
-        end)
+        end
         Console.interact_with_call call
       end
     end
   end
-end
+end

data/spec/adhearsion/events_spec.rb

@@ -21,7 +21,7 @@ module Adhearsion
       o = nil
       latch = CountDownLatch.new 1
 
-      flexmock(Events.instance).should_receive(:handle_message).and_return do |message|
+      Events.instance.should_receive(:handle_message).and_return do |message|
         t = message.type
         o = message.object
         latch.countdown!
@@ -38,7 +38,7 @@ module Adhearsion
       t = nil
       o = nil
 
-      flexmock(Events.instance).should_receive(:handle_message).and_return do |message|
+      Events.instance.should_receive(:handle_message).and_return do |message|
         sleep 0.25
         t = message.type
         o = message.object
@@ -65,7 +65,7 @@ module Adhearsion
     end
 
     it "should handle exceptions in event processing by raising the exception as an event" do
-      flexmock(Events.instance).should_receive(:trigger).with(:exception, ExceptionClass).once
+      Events.instance.should_receive(:trigger).with(:exception, kind_of(ExceptionClass)).once
 
       Events.register_handler :event, EventClass do |event|
         raise ExceptionClass

data/spec/adhearsion/initializer_spec.rb

@@ -12,9 +12,8 @@ describe Adhearsion::Initializer do
   describe "#start" do
     before do
       ::Logging.reset
-      flexmock(Adhearsion::Logging).should_receive(:start).once.and_return('')
-      flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
-      flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+      Adhearsion::Logging.should_receive(:start).once.and_return('')
+      ::Logging::Appenders.stub(:file => nil)
       Adhearsion.config = nil
     end
 
@@ -35,7 +34,7 @@ describe Adhearsion::Initializer do
     end
 
     it "should start the stats aggregator" do
-      flexmock(Adhearsion).should_receive(:statistics).at_least.once
+      Adhearsion.should_receive(:statistics).at_least(:once)
       stub_behavior_for_initializer_with_no_path_changing_behavior do
         Adhearsion::Initializer.start
       end
@@ -43,7 +42,7 @@ describe Adhearsion::Initializer do
 
     it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         ahn = Adhearsion::Initializer.start :pid_file => true
         ahn.pid_file[0, path.length].should be == path
       end
@@ -58,8 +57,8 @@ describe Adhearsion::Initializer do
 
     it "should create a pid file in the app's path by default when daemonizing" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(Adhearsion::CustomDaemonizer).should_receive(:daemonize).and_yield
-        flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
+        Adhearsion::CustomDaemonizer.should_receive(:daemonize).and_yield '123'
+        File.should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w')
         ahn = Adhearsion::Initializer.start :mode => :daemon
         ahn.pid_file[0, path.size].should be == path
       end
@@ -67,7 +66,7 @@ describe Adhearsion::Initializer do
 
     it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(Adhearsion::CustomDaemonizer).should_receive(:daemonize).and_yield
+        Adhearsion::CustomDaemonizer.should_receive(:daemonize).and_yield '123'
         ahn = Adhearsion::Initializer.start :mode => :daemon, :pid_file => false
         ahn.pid_file.should be nil
       end
@@ -85,55 +84,55 @@ describe Adhearsion::Initializer do
 
     it "should resolve the log file path to daemonize" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-         ahn = Adhearsion::Initializer.start :pid_file => true
-         ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        ahn = Adhearsion::Initializer.start :pid_file => true
+        ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
       end
     end
 
     it "should resolve the log file path to daemonize when outputters is an Array" do
       Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/adhearsion.log"]
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-         ahn = Adhearsion::Initializer.start :pid_file => true
-         ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        ahn = Adhearsion::Initializer.start :pid_file => true
+        ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
       end
     end
 
     it "should return a valid appenders array" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-         flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-         ahn = Adhearsion::Initializer.start :pid_file => true
-         appenders = ahn.init_get_logging_appenders
-         appenders.should have(2).items
-         appenders[1].should be_instance_of Logging::Appenders::Stdout
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        ahn = Adhearsion::Initializer.start :pid_file => true
+        appenders = ahn.init_get_logging_appenders
+        appenders.should have(2).items
+        appenders[1].should be_instance_of Logging::Appenders::Stdout
       end
     end
 
     it "should initialize properly the log paths" do
       ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         Adhearsion::Initializer.start :pid_file => true
       end
-      flexmock(Dir).should_receive(:mkdir).with("log/")
+      Dir.should_receive(:mkdir).with("log/")
       ahn.initialize_log_paths
     end
 
     it "should initialize properly the log paths when outputters is an array" do
       Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/test/adhearsion.log"]
       ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         Adhearsion::Initializer.start :pid_file => true
       end
-      flexmock(Dir).should_receive(:mkdir).with("log/").twice
-      flexmock(Dir).should_receive(:mkdir).with("log/test/").once
+      Dir.should_receive(:mkdir).with("log/").twice
+      Dir.should_receive(:mkdir).with("log/test/").once
       ahn.initialize_log_paths
     end
 
     it "should set the adhearsion proc name" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-        flexmock(Adhearsion::LinuxProcName).should_receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        Adhearsion::LinuxProcName.should_receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
         Adhearsion::Initializer.start :pid_file => true
       end
     end
@@ -149,8 +148,7 @@ describe Adhearsion::Initializer do
   describe "Initializing logger" do
     before do
       ::Logging.reset
-      flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
-      flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+      ::Logging::Appenders.should_receive(:file).and_return(nil)
       Adhearsion.config = nil
     end
 
@@ -163,8 +161,8 @@ describe Adhearsion::Initializer do
 
     it "should start logging with valid parameters" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
-        flexmock(Adhearsion::Logging).should_receive(:start).once.with(Array, :info, nil).and_return('')
+        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        Adhearsion::Logging.should_receive(:start).once.with(kind_of(Array), :info, nil).and_return('')
         Adhearsion::Initializer.start :pid_file => true
       end
     end
@@ -176,7 +174,7 @@ describe Adhearsion::Initializer do
     end
 
     it "should load the contents of lib directory" do
-      flexmock(Dir).should_receive(:chdir).with(File.join(path, "lib"), Proc).and_return []
+      Dir.should_receive(:chdir).with(File.join(path, "lib")).and_return []
       Adhearsion::Initializer.new.load_lib_folder
     end
 
@@ -192,7 +190,8 @@ describe Adhearsion::Initializer do
 
     it "should load the contents of the preconfigured directory" do
       Adhearsion.config.platform.lib = "foo"
-      flexmock(Dir).should_receive(:chdir).with("/any/ole/path/foo", Proc).and_return []
+      File.stub directory?: true
+      Dir.should_receive(:chdir).with(File.join(path, "foo")).and_return []
       Adhearsion::Initializer.new.load_lib_folder
     end
   end
@@ -203,9 +202,8 @@ describe "Updating RAILS_ENV variable" do
 
   before do
     ::Logging.reset
-    flexmock(Adhearsion::Logging).should_receive(:start).once.and_return('')
-    flexmock(::Logging::Appenders::File).should_receive(:assert_valid_logfile).and_return(true)
-    flexmock(::Logging::Appenders).should_receive(:file).and_return(nil)
+    Adhearsion::Logging.should_receive(:start).once.and_return('')
+    ::Logging::Appenders.should_receive(:file).and_return(nil)
     Adhearsion.config = nil
   end
 

data/spec/adhearsion/logging_spec.rb

@@ -34,14 +34,14 @@ describe Adhearsion::Logging do
   it "should log to the Object logger when given arguments" do
     message = "o hai. ur home erly."
     foo = Foo.new
-    flexmock(::Logging.logger[Foo]).should_receive(:info).once.with(message)
+    ::Logging.logger[Foo].should_receive(:info).once.with(message)
     foo.logger.info message
   end
 
   it "should log to the Object logger when given arguments (II)" do
     message = "o hai. ur home erly."
     bar = Foo::Bar.new
-    flexmock(::Logging.logger[Foo::Bar]).should_receive(:info).once.with(message)
+    ::Logging.logger[Foo::Bar].should_receive(:info).once.with(message)
     bar.logger.info message
   end
 
@@ -86,7 +86,7 @@ describe Adhearsion::Logging do
   end
 
   it 'should reopen logfiles' do
-    flexmock(::Logging).should_receive(:reopen).once
+    ::Logging.should_receive(:reopen).once
     Adhearsion::Logging.reopen_logs
   end
 

data/spec/adhearsion/outbound_call_spec.rb

@@ -9,7 +9,7 @@ module Adhearsion
     its(:id) { should be_nil }
     its(:variables) { should be == {} }
 
-    let(:mock_client) { flexmock 'Punchblock Client' }
+    let(:mock_client) { mock 'Punchblock Client' }
 
     before do
       PunchblockPlugin::Initializer.client = mock_client
@@ -24,35 +24,35 @@ module Adhearsion
 
       before do
         mock_call
-        flexmock(OutboundCall).should_receive(:new).and_return mock_call
+        OutboundCall.should_receive(:new).and_return mock_call
       end
 
       it "should dial the call to the correct endpoint and return it" do
-        flexmock(mock_call.wrapped_object).should_receive(:dial).with(to, :from => 'foo').once
+        mock_call.wrapped_object.should_receive(:dial).with(to, :from => 'foo').once
         OutboundCall.originate(to, :from => 'foo').should be mock_call
       end
 
       it "should run through the router when the call is answered" do
-        flexmock(mock_call.wrapped_object).should_receive(:dial).once
+        mock_call.wrapped_object.should_receive(:dial).once
 
-        flexmock(Adhearsion.router).should_receive(:handle).once.with(mock_call)
+        Adhearsion.router.should_receive(:handle).once.with(mock_call)
 
         OutboundCall.originate(to) << Punchblock::Event::Answered.new
       end
 
       context "when a controller class is specified for the call" do
-        let(:controller)  { CallController }
+        let(:controller) { CallController }
 
         it "should execute the controller on the call when it is answered" do
-          flexmock(mock_call).should_receive(:dial).once.with(to, {})
-          flexmock(mock_call).should_receive(:execute_controller).once.with controller, Proc
+          mock_call.should_receive(:dial).once.with(to, {})
+          mock_call.should_receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
           call = OutboundCall.originate to, :controller => controller
           call << Punchblock::Event::Answered.new
         end
 
         it "should hangup the call after all controllers have executed" do
-          flexmock(mock_call).should_receive(:dial).once
-          flexmock(mock_call).should_receive(:hangup).once
+          mock_call.should_receive(:dial).once
+          mock_call.should_receive(:hangup).once
 
           call = OutboundCall.originate to, :controller => controller
           call << Punchblock::Event::Answered.new
@@ -61,8 +61,10 @@ module Adhearsion
 
         context "with controller metadata specified" do
           it "should set the metadata on the controller" do
-            flexmock(mock_call).should_receive(:dial).once.with(to, {})
-            flexmock(mock_call).should_receive(:execute_controller).once.with(FlexMock.on { |c| c.is_a?(controller) && c.metadata == {:foo => 'bar'}}, Proc)
+            mock_call.should_receive(:dial).once.with(to, {})
+            mock_call.should_receive(:execute_controller).once do |c|
+              c.is_a?(controller) && c.metadata == {:foo => 'bar'}
+            end
             call = OutboundCall.originate to, :controller => controller, :controller_metadata => {:foo => 'bar'}
             call << Punchblock::Event::Answered.new
           end
@@ -71,8 +73,8 @@ module Adhearsion
 
       context "when given a block" do
         it "should execute the block as a controller on the call when it is answered" do
-          flexmock(mock_call).should_receive(:dial).once.with(to, {})
-          flexmock(mock_call).should_receive(:execute_controller).once.with(CallController, Proc).and_return do |controller|
+          mock_call.should_receive(:dial).once.with(to, {})
+          mock_call.should_receive(:execute_controller).once.with(kind_of(CallController), kind_of(Proc)).and_return do |controller|
             controller.block.call.should be == :foobar
           end
 
@@ -85,7 +87,7 @@ module Adhearsion
     end
 
     describe "event handlers" do
-      let(:response) { flexmock 'Response' }
+      let(:response) { mock 'Response' }
 
       describe "for answered events" do
         let(:event) { Punchblock::Event::Answered.new }
@@ -100,7 +102,7 @@ module Adhearsion
 
     describe "#dial" do
       def expect_message_waiting_for_response(message)
-        flexmock(subject.wrapped_object).should_receive(:write_and_await_response).once.with(message, 60).and_return do
+        subject.wrapped_object.should_receive(:write_and_await_response).once.with(message, 60).and_return do
           message.target_call_id = call_id
           message
         end
@@ -141,13 +143,13 @@ module Adhearsion
       end
 
       it "should add the call to the active calls registry" do
-        Adhearsion.active_calls.clear!
+        Adhearsion.active_calls.clear
         subject.dial to, :from => from
         Adhearsion.active_calls[call_id].should be subject
       end
 
       it "should immediately fire the :call_dialed event giving the call" do
-        flexmock(Adhearsion::Events).should_receive(:trigger_immediately).once.with(:call_dialed, subject)
+        Adhearsion::Events.should_receive(:trigger_immediately).once.with(:call_dialed, subject)
         subject.dial to, :from => from
       end
 
@@ -162,7 +164,7 @@ module Adhearsion
 
     describe "basic control commands" do
       def expect_no_message_waiting_for_response
-        flexmock(subject.wrapped_object).should_receive(:write_and_await_response).never
+        subject.wrapped_object.should_receive(:write_and_await_response).never
       end
 
       describe '#accept' do