adhearsion 2.3.0 → 2.3.1

data/spec/adhearsion/call_controller/output/async_player_spec.rb

@@ -9,7 +9,7 @@ module Adhearsion
       describe AsyncPlayer do
         include CallControllerTestHelpers
 
-        let(:controller) { flexmock new_controller }
+        let(:controller) { new_controller }
 
         subject { AsyncPlayer.new controller }
 
@@ -43,9 +43,9 @@ module Adhearsion
             response = Punchblock::Event::Complete.new
             response.reason = Punchblock::Event::Complete::Error.new
             component = Punchblock::Component::Output.new(:ssml => content)
-            flexmock subject, :new_output => component
+            subject.stub :new_output => component
             expect_message_waiting_for_response component
-            flexmock(controller.logger).should_receive(:error).once
+            controller.logger.should_receive(:error).once
             subject.output content
             component.request!
             component.execute!

data/spec/adhearsion/call_controller/output/player_spec.rb

@@ -9,7 +9,7 @@ module Adhearsion
       describe Player do
         include CallControllerTestHelpers
 
-        let(:controller) { flexmock new_controller }
+        let(:controller) { new_controller }
 
         subject { Player.new controller }
 

data/spec/adhearsion/call_controller/output_spec.rb

@@ -692,12 +692,7 @@ module Adhearsion
         }
 
         def expect_component_complete_event
-          complete_event = Punchblock::Event::Complete.new
-          flexmock(complete_event).should_receive(:reason => flexmock(:utterance => 'dtmf-5'))
-          flexmock(Punchblock::Component::Input).new_instances do |input|
-            input.should_receive(:complete?).and_return(false)
-            input.should_receive(:complete_event).and_return(complete_event)
-          end
+          expect_input_component_complete_event 'dtmf-5'
         end
 
         #test does pass and method works, but not sure if the empty method is a good idea
@@ -717,7 +712,7 @@ module Adhearsion
           end
 
           expect_component_complete_event
-          flexmock(Punchblock::Component::Output).new_instances.should_receive(:stop!)
+          Punchblock::Component::Output.any_instance.should_receive(:stop!)
           expect_component_execution output_component
           subject.stream_file(prompt, allowed_digits).should be == '5'
         end

data/spec/adhearsion/call_controller/record_spec.rb

@@ -101,7 +101,7 @@ module Adhearsion
               end
 
               it "stops the recording" do
-                flexmock(subject.record_component).should_receive(:stop!).once
+                subject.record_component.should_receive(:stop!).once
                 subject.stopper_component.trigger_event_handler complete_event
               end
             end
@@ -110,7 +110,7 @@ module Adhearsion
               it "stops the input component" do
                 controller.should_receive(:execute_component_and_await_completion).once.with(component)
                 controller.should_receive(:write_and_await_response).once.with(input_component)
-                flexmock(subject.stopper_component).should_receive(:stop!).once
+                subject.stopper_component.should_receive(:stop!).once
                 subject.run
               end
             end
@@ -139,8 +139,8 @@ module Adhearsion
           let(:complete_event) { Punchblock::Event::Complete.new }
 
           it "should execute those handlers when recording completes" do
-            foo = flexmock 'foo'
-            foo.should_receive(:call).once.with Punchblock::Event::Complete
+            foo = mock 'foo'
+            foo.should_receive(:call).once.with kind_of(Punchblock::Event::Complete)
             subject.handle_record_completion { |e| foo.call e }
             subject.record_component.trigger_event_handler complete_event
           end
@@ -164,7 +164,7 @@ module Adhearsion
         describe "with :async => true and an :on_complete callback" do
           before do
             component
-            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(parsed_options).and_return component
+            Punchblock::Component::Record.should_receive(:new).once.with(parsed_options).and_return component
             expect_message_waiting_for_response component
             @rec = Queue.new
             subject.record(options.merge(async: true)) { |rec| @rec.push rec }
@@ -184,7 +184,7 @@ module Adhearsion
           before do
             TestException = Class.new StandardError
             component
-            flexmock(Punchblock::Component::Record).should_receive(:new).once.with({}).and_return component
+            Punchblock::Component::Record.should_receive(:new).once.with({}).and_return component
           end
 
           it "should pass the exception to the events system" do
@@ -207,7 +207,7 @@ module Adhearsion
         describe "with :async => false" do
           before do
             component
-            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(parsed_options).and_return component
+            Punchblock::Component::Record.should_receive(:new).once.with(parsed_options).and_return component
             expect_component_execution component
             @rec = Queue.new
             subject.record(options.merge(:async => false)) { |rec| @rec.push rec }
@@ -233,21 +233,14 @@ module Adhearsion
         end
 
         describe "with :interruptible => true" do
-          let(:input_component) { Punchblock::Component::Input.new }
           it "stops the recording" do
-            flexmock(Punchblock::Event::Complete).new_instances.should_receive(:reason => flexmock(:name => :input))
-
             def subject.write_and_await_response(input_component)
               input_component.trigger_event_handler Punchblock::Event::Complete.new
             end
 
-            complete_event = Punchblock::Event::Complete.new
-            flexmock(complete_event).should_receive(:reason => flexmock(:name => :input))
-            flexmock(Punchblock::Component::Input).new_instances do |input|
-              input.should_receive(:complete?).and_return(true)
-              input.should_receive(:complete_event).and_return(complete_event)
-            end
-            flexmock(Punchblock::Component::Record).new_instances.should_receive(:stop!)
+            expect_input_component_complete_event 'dtmf-5'
+
+            Punchblock::Component::Record.any_instance.should_receive(:stop!)
             subject.should_receive(:execute_component_and_await_completion).once.with(component)
             subject.record(options.merge(:async => false, :interruptible => true)) { |rec| @rec.push rec }
           end
@@ -257,7 +250,7 @@ module Adhearsion
         describe "check for the return value" do
           it "returns a Record component" do
             component
-            flexmock(Punchblock::Component::Record).should_receive(:new).once.with(parsed_options).and_return component
+            Punchblock::Component::Record.should_receive(:new).once.with(parsed_options).and_return component
             expect_component_execution component
             subject.record(options.merge(:async => false)).should be == component
             component.request!

data/spec/adhearsion/call_controller_spec.rb

@@ -30,18 +30,18 @@ module Adhearsion
 
     describe "execution on a call" do
       before do
-        flexmock subject, :execute_component_and_await_completion => nil
-        flexmock call.wrapped_object, :write_and_await_response => nil
+        subject.stub :execute_component_and_await_completion => nil
+        call.wrapped_object.stub :write_and_await_response => nil
       end
 
       it "catches Hangup exceptions and logs the hangup" do
-        subject.should_receive(:run).once.and_raise(Call::Hangup).ordered
-        flexmock(subject.logger).should_receive(:info).once.with(/Call was hung up/).ordered
+        subject.should_receive(:run).once.ordered.and_raise(Call::Hangup)
+        subject.logger.should_receive(:info).once.with(/Call was hung up/).ordered
         subject.execute!
       end
 
       it "catches standard errors, triggering an exception event" do
-        subject.should_receive(:run).once.and_raise(StandardError).ordered
+        subject.should_receive(:run).once.ordered.and_raise(StandardError)
         latch = CountDownLatch.new 1
         ex = lo = nil
         Events.exception do |e, l|
@@ -62,7 +62,7 @@ module Adhearsion
         its(:block) { should be block }
 
         it "should execute the block in the context of the controller" do
-          flexmock subject, :value => :bar
+          subject.stub :value => :bar
           subject.should_receive(:foo).once.with(:bar)
           subject.run
         end
@@ -112,10 +112,10 @@ module Adhearsion
       subject { InvokeController.new call }
 
       before do
-        flexmock subject, :execute_component_and_await_completion => nil
-        flexmock call.wrapped_object, :write_and_await_response => nil
-        flexmock call, :register_controller => nil
-        flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
+        subject.stub :execute_component_and_await_completion => nil
+        call.wrapped_object.stub :write_and_await_response => nil
+        call.stub :register_controller => nil
+        Events.should_receive(:trigger).with(:exception, Exception).never
       end
 
       it "should invoke another controller before returning to the current controller" do
@@ -127,13 +127,13 @@ module Adhearsion
       end
 
       it "should return the outer controller's run method return value" do
-        flexmock(SecondController).new_instances.should_receive(:run).once.and_return(:run_result)
+        SecondController.any_instance.should_receive(:run).once.and_return(:run_result)
         subject.execute!
         subject.metadata[:invoke_result].should be == :run_result
       end
 
       it "should invoke the new controller with metadata" do
-        flexmock(SecondController).new_instances.should_receive(:md_check).once.with :foo => 'bar'
+        SecondController.any_instance.should_receive(:md_check).once.with :foo => 'bar'
         subject.execute!
       end
 
@@ -171,11 +171,11 @@ module Adhearsion
       subject { PassController.new call }
 
       before do
-        flexmock call.wrapped_object, :write_and_await_response => nil
-        flexmock call, :register_controller => nil
-        flexmock subject, :execute_component_and_await_completion => nil
-        flexmock(SecondController).new_instances.should_receive(:md_check).once.with :foo => 'bar'
-        flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
+        call.wrapped_object.stub :write_and_await_response => nil
+        call.stub :register_controller => nil
+        subject.stub :execute_component_and_await_completion => nil
+        SecondController.any_instance.should_receive(:md_check).once.with :foo => 'bar'
+        Events.should_receive(:trigger).with(:exception, Exception).never
       end
 
       it "should cease execution of the current controller, and instruct the call to execute another" do
@@ -199,8 +199,8 @@ module Adhearsion
       let(:message) { Punchblock::Command::Accept.new }
 
       it "delegates to the call, blocking first until it is allowed to execute" do
-        flexmock(subject).should_receive(:block_until_resumed).once.ordered
-        flexmock(subject.call).should_receive(:write_and_await_response).once.ordered.with(message)
+        subject.should_receive(:block_until_resumed).once.ordered
+        subject.call.should_receive(:write_and_await_response).once.ordered.with(message)
         subject.write_and_await_response message
       end
     end
@@ -211,8 +211,8 @@ module Adhearsion
       :unmute].each do |method_name|
       describe "##{method_name}" do
         it "delegates to the call, blocking first until it is allowed to execute" do
-          flexmock(subject).should_receive(:block_until_resumed).once.ordered
-          flexmock(subject.call).should_receive(method_name).once.ordered
+          subject.should_receive(:block_until_resumed).once.ordered
+          subject.call.should_receive(method_name).once.ordered
           subject.send method_name
         end
       end
@@ -220,16 +220,16 @@ module Adhearsion
 
     describe "#hangup" do
       it "delegates to the call, blocking first until it is allowed to execute" do
-        flexmock(subject).should_receive(:block_until_resumed).once.ordered
-        flexmock(subject.call).should_receive(:hangup).once.ordered
+        subject.should_receive(:block_until_resumed).once.ordered
+        subject.call.should_receive(:hangup).once.ordered
         lambda { subject.send :hangup }.should raise_error Call::Hangup
       end
     end
 
     describe "#join" do
       it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
-        flexmock(subject).should_receive(:block_until_resumed).once.ordered
-        flexmock(subject.call).should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:call_id => 'call1')
+        subject.should_receive(:block_until_resumed).once.ordered
+        subject.call.should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:call_id => 'call1')
         latch = CountDownLatch.new 1
         Thread.new do
           subject.join 'call1', :foo => :bar
@@ -244,8 +244,8 @@ module Adhearsion
 
       context "with a mixer" do
         it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
-          flexmock(subject).should_receive(:block_until_resumed).once.ordered
-          flexmock(subject.call).should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
+          subject.should_receive(:block_until_resumed).once.ordered
+          subject.call.should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
           latch = CountDownLatch.new 1
           Thread.new do
             subject.join :mixer_name => 'foobar', :foo => :bar
@@ -261,8 +261,8 @@ module Adhearsion
 
       context "with :async => true" do
         it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
-          flexmock(subject).should_receive(:block_until_resumed).once.ordered
-          flexmock(subject.call).should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:call_id => 'call1')
+          subject.should_receive(:block_until_resumed).once.ordered
+          subject.call.should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:call_id => 'call1')
           latch = CountDownLatch.new 1
           Thread.new do
             subject.join 'call1', :foo => :bar, :async => true
@@ -275,8 +275,8 @@ module Adhearsion
 
         context "with a mixer" do
           it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
-            flexmock(subject).should_receive(:block_until_resumed).once.ordered
-            flexmock(subject.call).should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
+            subject.should_receive(:block_until_resumed).once.ordered
+            subject.call.should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
             latch = CountDownLatch.new 1
             Thread.new do
               subject.join :mixer_name => 'foobar', :foo => :bar, :async => true
@@ -414,8 +414,8 @@ describe ExampleCallController do
   include CallControllerTestHelpers
 
   before do
-    flexmock subject, :execute_component_and_await_completion => nil
-    flexmock call.wrapped_object, :write_and_await_response => nil
+    subject.stub :execute_component_and_await_completion => nil
+    call.wrapped_object.stub :write_and_await_response => nil
   end
 
   it "should execute the before_call callbacks before processing the call" do
@@ -432,8 +432,8 @@ describe ExampleCallController do
   end
 
   it "should capture errors in callbacks" do
-    subject.should_receive(:setup_models).and_raise StandardError
-    subject.should_receive(:clean_up_models).and_raise StandardError
+    subject.should_receive(:setup_models).twice.and_raise StandardError
+    subject.should_receive(:clean_up_models).twice.and_raise StandardError
     latch = CountDownLatch.new 4
     Adhearsion::Events.exception do |e, l|
       e.should be_a StandardError

data/spec/adhearsion/call_spec.rb

@@ -10,7 +10,7 @@ end
 
 module Adhearsion
   describe Call do
-    let(:mock_client) { flexmock('Client').tap(&:should_ignore_missing) }
+    let(:mock_client) { mock('Client').as_null_object }
 
     let(:call_id) { rand }
     let(:headers) { nil }
@@ -26,7 +26,7 @@ module Adhearsion
     subject { Adhearsion::Call.new offer }
 
     before do
-      flexmock(offer).should_receive(:client).and_return(mock_client)
+      offer.stub(:client).and_return(mock_client)
     end
 
     after do
@@ -97,16 +97,16 @@ module Adhearsion
     end
 
     it 'allows the registration of event handlers which are called when messages are delivered' do
-      event = flexmock 'Event'
+      event = mock 'Event'
       event.should_receive(:foo?).and_return true
-      response = flexmock 'Response'
+      response = mock 'Response'
       response.should_receive(:call).once
       subject.register_event_handler(:foo?) { response.call }
       subject << event
     end
 
     describe "event handlers" do
-      let(:response) { flexmock 'Response' }
+      let(:response) { mock 'Response' }
 
       describe "for joined events" do
         context "joined to another call" do
@@ -178,7 +178,8 @@ module Adhearsion
 
           it "should trigger any on_unjoined callbacks set for the matching call" do
             response.should_receive(:call).once.with(event)
-            call = flexmock Call.new, :id => 'foobar'
+            call = Call.new
+            call.stub :id => 'foobar'
             subject.on_unjoined(call) { |event| response.call event }
             subject << event
           end
@@ -227,7 +228,8 @@ module Adhearsion
 
           it "should not trigger any on_unjoined callbacks set for the matching call" do
             response.should_receive(:call).never
-            call = flexmock Call.new, :id => 'foobar'
+            call = Call.new
+            call.stub :id => 'foobar'
             subject.on_unjoined(call) { |event| response.call event }
             subject << event
           end
@@ -271,7 +273,9 @@ module Adhearsion
 
     context "peer registry" do
       let(:other_call_id) { 'foobar' }
-      let(:other_call) { flexmock Call.new, :id => other_call_id }
+      let(:other_call) { Call.new }
+
+      before { other_call.stub :id => other_call_id }
 
       let :joined_event do
         Punchblock::Event::Joined.new :call_id => other_call_id
@@ -329,7 +333,7 @@ module Adhearsion
         end
 
         it "should instruct the command registry to terminate" do
-          flexmock(subject.commands).should_receive(:terminate).once
+          subject.commands.should_receive(:terminate).once
           subject << end_event
         end
 
@@ -401,18 +405,17 @@ module Adhearsion
     end
 
     describe "#write_command" do
-      let(:mock_command) { flexmock('Command') }
+      let(:mock_command) { mock('Command') }
 
       it "should asynchronously write the command to the Punchblock connection" do
-        mock_client = flexmock('Client')
-        flexmock(subject.wrapped_object).should_receive(:client).once.and_return mock_client
+        subject.wrapped_object.should_receive(:client).once.and_return mock_client
         mock_client.should_receive(:execute_command).once.with(mock_command, :call_id => subject.id, :async => true).and_return true
         subject.write_command mock_command
       end
 
       describe "with a hungup call" do
         before do
-          flexmock(subject.wrapped_object).should_receive(:active?).and_return(false)
+          subject.wrapped_object.should_receive(:active?).and_return(false)
         end
 
         it "should raise a Hangup exception" do
@@ -434,12 +437,12 @@ module Adhearsion
       let(:response) { :foo }
 
       before do
-        flexmock(message).should_receive(:execute!).and_return true
+        message.should_receive(:execute!).and_return true
         message.response = response
       end
 
       it "writes a command to the call" do
-        flexmock(subject.wrapped_object).should_receive(:write_command).once.with(message)
+        subject.wrapped_object.should_receive(:write_command).once.with(message)
         subject.write_and_await_response message
       end
 
@@ -471,7 +474,7 @@ module Adhearsion
         let(:response) { new_exception.new }
 
         it "raises the error" do
-          flexmock(Events).should_receive(:trigger).never
+          Events.should_receive(:trigger).never
           lambda { subject.write_and_await_response message }.should raise_error new_exception
         end
 
@@ -479,7 +482,7 @@ module Adhearsion
           let(:response) { new_exception.new.setup :item_not_found }
 
           it "should raise a Hangup exception" do
-            flexmock(Events).should_receive(:trigger).never
+            Events.should_receive(:trigger).never
             lambda { subject.write_and_await_response message }.should raise_error Call::Hangup
           end
         end
@@ -499,10 +502,14 @@ module Adhearsion
     end
 
     describe "basic control commands" do
-      include FlexMock::ArgumentTypes
-
-      def expect_message_waiting_for_response(message)
-        flexmock(subject.wrapped_object).should_receive(:write_and_await_response).once.with(message).and_return(message)
+      def expect_message_waiting_for_response(message = nil, fail = false, &block)
+        expectation = subject.wrapped_object.should_receive(:write_and_await_response, &block).once
+        expectation = expectation.with message if message
+        if fail
+          expectation.and_raise fail
+        else
+          expectation.and_return message
+        end
       end
 
       describe '#accept' do
@@ -564,7 +571,9 @@ module Adhearsion
 
         describe "with no headers" do
           it 'should send a Reject message' do
-            expect_message_waiting_for_response on { |c| c.is_a?(Punchblock::Command::Reject) && c.headers_hash == {} }
+            expect_message_waiting_for_response do |c|
+              c.is_a?(Punchblock::Command::Reject) && c.headers_hash == {}
+            end
             subject.reject
           end
         end
@@ -572,14 +581,16 @@ module Adhearsion
         describe "with headers set" do
           it 'should send a Hangup message with the correct headers' do
             headers = {:foo => 'bar'}
-            expect_message_waiting_for_response on { |c| c.is_a?(Punchblock::Command::Reject) && c.headers_hash == headers }
+            expect_message_waiting_for_response do |c|
+              c.is_a?(Punchblock::Command::Reject) && c.headers_hash == headers
+            end
             subject.reject nil, headers
           end
         end
 
         it "should immediately fire the :call_rejected event giving the call and the reason" do
-          expect_message_waiting_for_response Punchblock::Command::Reject
-          flexmock(Adhearsion::Events).should_receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
+          expect_message_waiting_for_response kind_of(Punchblock::Command::Reject)
+          Adhearsion::Events.should_receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
           subject.reject :decline
         end
       end
@@ -587,11 +598,11 @@ module Adhearsion
       describe "#hangup" do
         describe "if the call is not active" do
           before do
-            flexmock(subject.wrapped_object).should_receive(:active?).and_return false
+            subject.wrapped_object.should_receive(:active?).and_return false
           end
 
           it "should do nothing and return false" do
-            flexmock(subject).should_receive(:write_and_await_response).never
+            subject.should_receive(:write_and_await_response).never
             subject.hangup.should be false
           end
         end
@@ -629,7 +640,9 @@ module Adhearsion
 
         context "with a call" do
           let(:call_id) { rand.to_s }
-          let(:target)  { flexmock Call.new, :id => call_id }
+          let(:target)  { described_class.new }
+
+          before { target.stub id: call_id }
 
           it "should send a join command joining to the provided call ID" do
             expect_join_with_options :call_id => call_id
@@ -714,7 +727,9 @@ module Adhearsion
 
         context "with a call" do
           let(:call_id) { rand.to_s }
-          let(:target)  { flexmock Call.new, :id => call_id }
+          let(:target)  { described_class.new }
+
+          before { target.stub id: call_id }
 
           it "should send an unjoin command unjoining from the provided call ID" do
             expect_unjoin_with_options :call_id => call_id
@@ -778,10 +793,10 @@ module Adhearsion
 
       describe "#execute_controller" do
         let(:latch)           { CountDownLatch.new 1 }
-        let(:mock_controller) { flexmock CallController.new(subject) }
+        let(:mock_controller) { CallController.new(subject) }
 
         before do
-          flexmock subject.wrapped_object, :write_and_await_response => true
+          subject.wrapped_object.stub :write_and_await_response => true
         end
 
         it "should call #bg_exec on the controller instance" do
@@ -792,7 +807,7 @@ module Adhearsion
 
         it "should use the passed block as a controller if none is specified" do
           mock_controller.should_receive(:exec).once
-          flexmock(CallController).should_receive(:new).once.and_return mock_controller
+          CallController.should_receive(:new).once.and_return mock_controller
           subject.execute_controller nil, lambda { |call| latch.countdown! } do
             foo
           end
@@ -816,7 +831,6 @@ module Adhearsion
         end
 
         it "should execute a callback after the controller executes" do
-          flexmock(CallController).should_receive(:exec)
           foo = nil
           subject.execute_controller mock_controller, lambda { |call| foo = call; latch.countdown! }
           latch.wait(3).should be_true
@@ -832,8 +846,8 @@ module Adhearsion
       end
 
       context "with two controllers registered" do
-        let(:controller1) { flexmock 'CallController1' }
-        let(:controller2) { flexmock 'CallController2' }
+        let(:controller1) { mock 'CallController1' }
+        let(:controller2) { mock 'CallController2' }
 
         before { subject.controllers << controller1 << controller2 }