punchblock 2.5.2 → 2.5.3

data/spec/punchblock/translator/asterisk/component_spec.rb

@@ -34,7 +34,7 @@ module Punchblock
             end
 
             it "should send the event to the connection" do
-              connection.should_receive(:handle_event).once.with expected_event
+              expect(connection).to receive(:handle_event).once.with expected_event
               subject.send_event event
             end
           end
@@ -48,14 +48,14 @@ module Punchblock
             end
 
             it "should send a complete event with the specified reason" do
-              subject.should_receive(:send_event).once.with expected_event
+              expect(subject).to receive(:send_event).once.with expected_event
               subject.send_complete_event reason
             end
           end
 
           describe "#call_ended" do
             it "should send a complete event with the call hangup reason" do
-              subject.should_receive(:send_complete_event).once.with Punchblock::Event::Complete::Hangup.new
+              expect(subject).to receive(:send_complete_event).once.with Punchblock::Event::Complete::Hangup.new
               subject.call_ended
             end
           end
@@ -72,7 +72,7 @@ module Punchblock
 
               it 'sends an error in response to the command' do
                 subject.execute_command component_command
-                component_command.response.should be == ProtocolError.new.setup('command-not-acceptable', "Did not understand command for component #{subject.id}", call.id, subject.id)
+                expect(component_command.response).to eq(ProtocolError.new.setup('command-not-acceptable', "Did not understand command for component #{subject.id}", call.id, subject.id))
               end
             end
           end

data/spec/punchblock/translator/asterisk_spec.rb

@@ -13,8 +13,15 @@ module Punchblock
 
       subject { translator }
 
-      its(:ami_client) { should be ami_client }
-      its(:connection) { should be connection }
+      describe '#ami_client' do
+        subject { super().ami_client }
+        it { should be ami_client }
+      end
+
+      describe '#connection' do
+        subject { super().connection }
+        it { should be connection }
+      end
 
       before do
         connection.event_handler = ->(*) {}
@@ -28,10 +35,10 @@ module Punchblock
           let(:call_id) { 'abc123' }
 
           it 'executes the call command' do
-            subject.wrapped_object.should_receive(:execute_call_command).with do |c|
-              c.should be command
-              c.target_call_id.should be == call_id
-            end
+            expect(subject.wrapped_object).to receive(:execute_call_command).with { |c|
+              expect(c).to be command
+              expect(c.target_call_id).to eq(call_id)
+            }
             subject.execute_command command, :call_id => call_id
           end
         end
@@ -41,10 +48,10 @@ module Punchblock
           let(:component_id)  { '123abc' }
 
           it 'executes the component command' do
-            subject.wrapped_object.should_receive(:execute_component_command).with do |c|
-              c.should be command
-              c.component_id.should be == component_id
-            end
+            expect(subject.wrapped_object).to receive(:execute_component_command).with { |c|
+              expect(c).to be command
+              expect(c.component_id).to eq(component_id)
+            }
             subject.execute_command command, :component_id => component_id
           end
         end
@@ -53,7 +60,7 @@ module Punchblock
           let(:command) { Command::Dial.new }
 
           it 'executes the command directly' do
-            subject.wrapped_object.should_receive(:execute_global_command).with command
+            expect(subject.wrapped_object).to receive(:execute_global_command).with command
             subject.execute_command command
           end
         end
@@ -65,19 +72,19 @@ module Punchblock
         let(:call) { Translator::Asterisk::Call.new 'SIP/foo', subject, ami_client, connection }
 
         before do
-          call.stub(:id).and_return call_id
+          allow(call).to receive(:id).and_return call_id
           subject.register_call call
         end
 
         it 'sends the command to the call for execution' do
-          call.should_receive(:send_message).once.with body
+          expect(call).to receive(:send_message).once.with body
           subject.send_message call_id, 'example.com', body, subject: 'stuff'
         end
 
         context "when the call doesn't exist" do
           it "should not crash the translator" do
             subject.send_message 'oops', 'example.com', body, subject: 'stuff'
-            subject.should be_alive
+            expect(subject).to be_alive
           end
         end
       end
@@ -88,16 +95,16 @@ module Punchblock
         let(:call)    { Translator::Asterisk::Call.new channel, subject, ami_client, connection }
 
         before do
-          call.stub(:id).and_return call_id
+          allow(call).to receive(:id).and_return call_id
           subject.register_call call
         end
 
         it 'should make the call accessible by ID' do
-          subject.call_with_id(call_id).should be call
+          expect(subject.call_with_id(call_id)).to be call
         end
 
         it 'should make the call accessible by channel' do
-          subject.call_for_channel(channel).should be call
+          expect(subject.call_for_channel(channel)).to be call
         end
       end
 
@@ -107,20 +114,20 @@ module Punchblock
         let(:call)    { Translator::Asterisk::Call.new channel, subject, ami_client, connection }
 
         before do
-          call.stub(:id).and_return call_id
+          allow(call).to receive(:id).and_return call_id
           subject.register_call call
         end
 
         it 'should make the call inaccessible by ID' do
-          subject.call_with_id(call_id).should be call
+          expect(subject.call_with_id(call_id)).to be call
           subject.deregister_call call_id, channel
-          subject.call_with_id(call_id).should be_nil
+          expect(subject.call_with_id(call_id)).to be_nil
         end
 
         it 'should make the call inaccessible by channel' do
-          subject.call_for_channel(channel).should be call
+          expect(subject.call_for_channel(channel)).to be call
           subject.deregister_call call_id, channel
-          subject.call_for_channel(channel).should be_nil
+          expect(subject.call_for_channel(channel)).to be_nil
         end
       end
 
@@ -130,7 +137,7 @@ module Punchblock
 
         it 'should make the component accessible by ID' do
           subject.register_component component
-          subject.component_with_id(component_id).should be component
+          expect(subject.component_with_id(component_id)).to be component
         end
       end
 
@@ -143,18 +150,18 @@ module Punchblock
 
           before do
             command.request!
-            call.stub(:id).and_return call_id
+            allow(call).to receive(:id).and_return call_id
             subject.register_call call
           end
 
           it 'sends the command to the call for execution' do
-            call.should_receive(:execute_command).once.with command
+            expect(call).to receive(:execute_command).once.with command
             subject.execute_call_command command
           end
 
           context 'when it raises' do
             before do
-              call.should_receive(:execute_command).and_raise StandardError
+              expect(call).to receive(:execute_command).and_raise StandardError
             end
 
             let(:other_command) { Command::Answer.new target_call_id: call_id }
@@ -162,11 +169,11 @@ module Punchblock
             it 'sends an error in response to the command' do
               subject.execute_call_command command
 
-              subject.call_with_id(call_id).should be_nil
+              expect(subject.call_with_id(call_id)).to be_nil
 
               other_command.request!
               subject.execute_call_command other_command
-              other_command.response.should be == ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{call_id}", call_id)
+              expect(other_command.response).to eq(ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{call_id}", call_id))
             end
           end
         end
@@ -179,7 +186,7 @@ module Punchblock
           it 'sends an error in response to the command' do
             command.request!
             subject.execute_call_command command
-            command.response.should be == ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{call_id}", call_id, nil)
+            expect(command.response).to eq(ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{call_id}", call_id, nil))
           end
         end
       end
@@ -201,7 +208,7 @@ module Punchblock
           end
 
           it 'sends the command to the component for execution' do
-            component.should_receive(:execute_command).once.with command
+            expect(component).to receive(:execute_command).once.with command
             subject.execute_component_command command
           end
         end
@@ -209,7 +216,7 @@ module Punchblock
         context "with an unknown component ID" do
           it 'sends an error in response to the command' do
             subject.execute_component_command command
-            command.response.should be == ProtocolError.new.setup(:item_not_found, "Could not find a component with ID #{component.id}", nil, component.id)
+            expect(command.response).to eq(ProtocolError.new.setup(:item_not_found, "Could not find a component with ID #{component.id}", nil, component.id))
           end
         end
       end
@@ -222,19 +229,19 @@ module Punchblock
 
           before do
             command.request!
-            ami_client.stub(:send_action).and_return RubyAMI::Response.new
+            allow(ami_client).to receive(:send_action).and_return RubyAMI::Response.new
           end
 
           it 'should be able to look up the call by channel ID' do
             subject.execute_global_command command
             call = subject.call_for_channel('SIP/1234')
-            call.should be_a Asterisk::Call
+            expect(call).to be_a Asterisk::Call
           end
 
           it 'should instruct the call to send a dial' do
             mock_call = double('Asterisk::Call').as_null_object
-            Asterisk::Call.should_receive(:new).once.and_return mock_call
-            mock_call.should_receive(:dial).once.with command
+            expect(Asterisk::Call).to receive(:new).once.and_return mock_call
+            expect(mock_call).to receive(:dial).once.with command
             subject.execute_global_command command
           end
 
@@ -247,7 +254,7 @@ module Punchblock
 
             it "should assign the requested URI to the call" do
               subject.execute_global_command command
-              subject.call_with_id(requested_uri).id.should == requested_uri
+              expect(subject.call_with_id(requested_uri).id).to eq(requested_uri)
             end
 
             context 'and the requested URI already represents a known call' do
@@ -263,11 +270,11 @@ module Punchblock
               end
 
               it "should set the command response to a conflict error" do
-                command.response(0.1).should == ProtocolError.new.setup(:conflict, 'Call ID already in use')
+                expect(command.response(0.1)).to eq(ProtocolError.new.setup(:conflict, 'Call ID already in use'))
               end
 
               it "should not replace the original call in the registry" do
-                subject.call_with_id(requested_uri).should be @first_call
+                expect(subject.call_with_id(requested_uri)).to be @first_call
               end
             end
           end
@@ -281,14 +288,14 @@ module Punchblock
           let(:mock_action) { double('Asterisk::Component::Asterisk::AMIAction').as_null_object }
 
           it 'should create a component actor and execute it asynchronously' do
-            Asterisk::Component::Asterisk::AMIAction.should_receive(:new).once.with(command, subject, ami_client).and_return mock_action
-            mock_action.should_receive(:execute).once
+            expect(Asterisk::Component::Asterisk::AMIAction).to receive(:new).once.with(command, subject, ami_client).and_return mock_action
+            expect(mock_action).to receive(:execute).once
             subject.execute_global_command command
           end
 
           it 'registers the component' do
-            Asterisk::Component::Asterisk::AMIAction.should_receive(:new).once.with(command, subject, ami_client).and_return mock_action
-            subject.wrapped_object.should_receive(:register_component).with mock_action
+            expect(Asterisk::Component::Asterisk::AMIAction).to receive(:new).once.with(command, subject, ami_client).and_return mock_action
+            expect(subject.wrapped_object).to receive(:register_component).with mock_action
             subject.execute_global_command command
           end
         end
@@ -300,7 +307,7 @@ module Punchblock
 
           it 'sends an error in response to the command' do
             subject.execute_command command
-            command.response.should be == ProtocolError.new.setup('command-not-acceptable', "Did not understand command")
+            expect(command.response).to eq(ProtocolError.new.setup('command-not-acceptable', "Did not understand command"))
           end
         end
       end
@@ -308,7 +315,7 @@ module Punchblock
       describe '#handle_pb_event' do
         it 'should forward the event to the connection' do
           event = double 'Punchblock::Event'
-          subject.connection.should_receive(:handle_event).once.with event
+          expect(subject.connection).to receive(:handle_event).once.with event
           subject.handle_pb_event event
         end
       end
@@ -331,7 +338,7 @@ module Punchblock
         end
 
         it 'should create a Punchblock AMI event object and pass it to the connection' do
-          subject.connection.should_receive(:handle_event).once.with expected_pb_event
+          expect(subject.connection).to receive(:handle_event).once.with expected_pb_event
           subject.handle_ami_event ami_event
         end
 
@@ -340,14 +347,14 @@ module Punchblock
           after { described_class.event_filter = nil }
 
           it 'does not send the AMI event to the connection as a PB event' do
-            subject.connection.should_receive(:handle_event).never
+            expect(subject.connection).to receive(:handle_event).never
             subject.handle_ami_event ami_event
           end
         end
 
         context 'with something that is not a RubyAMI::Event' do
           it 'does not send anything to the connection' do
-            subject.connection.should_receive(:handle_event).never
+            expect(subject.connection).to receive(:handle_event).never
             subject.handle_ami_event :foo
           end
         end
@@ -356,8 +363,8 @@ module Punchblock
           let(:ami_event) { RubyAMI::Event.new 'FullyBooted' }
 
           it 'sends a connected event to the event handler' do
-            subject.connection.should_receive(:handle_event).once.with Connection::Connected.new
-            subject.wrapped_object.should_receive(:run_at_fully_booted).once
+            expect(subject.connection).to receive(:handle_event).once.with Connection::Connected.new
+            expect(subject.wrapped_object).to receive(:run_at_fully_booted).once
             subject.handle_ami_event ami_event
           end
         end
@@ -370,14 +377,14 @@ module Punchblock
               'Env'      => "agi_request%3A%20async%0Aagi_channel%3A%20SIP%2F1234-00000000%0Aagi_language%3A%20en%0Aagi_type%3A%20SIP%0Aagi_uniqueid%3A%201320835995.0%0Aagi_version%3A%201.8.4.1%0Aagi_callerid%3A%205678%0Aagi_calleridname%3A%20Jane%20Smith%0Aagi_callingpres%3A%200%0Aagi_callingani2%3A%200%0Aagi_callington%3A%200%0Aagi_callingtns%3A%200%0Aagi_dnid%3A%201000%0Aagi_rdnis%3A%20unknown%0Aagi_context%3A%20default%0Aagi_extension%3A%201000%0Aagi_priority%3A%201%0Aagi_enhanced%3A%200.0%0Aagi_accountcode%3A%20%0Aagi_threadid%3A%204366221312%0A%0A"
           end
 
-          before { subject.wrapped_object.stub :handle_pb_event }
+          before { allow(subject.wrapped_object).to receive :handle_pb_event }
 
           it 'should be able to look up the call by channel ID' do
             subject.handle_ami_event ami_event
             call = subject.call_for_channel('SIP/1234-00000000')
-            call.should be_a Asterisk::Call
-            call.agi_env.should be_a Hash
-            call.agi_env.should be == {
+            expect(call).to be_a Asterisk::Call
+            expect(call.agi_env).to be_a Hash
+            expect(call.agi_env).to eq({
               :agi_request      => 'async',
               :agi_channel      => 'SIP/1234-00000000',
               :agi_language     => 'en',
@@ -398,13 +405,13 @@ module Punchblock
               :agi_enhanced     => '0.0',
               :agi_accountcode  => '',
               :agi_threadid     => '4366221312'
-            }
+            })
           end
 
           it 'should instruct the call to send an offer' do
             mock_call = double('Asterisk::Call').as_null_object
-            Asterisk::Call.should_receive(:new).once.and_return mock_call
-            mock_call.should_receive(:send_offer).once
+            expect(Asterisk::Call).to receive(:new).once.and_return mock_call
+            expect(mock_call).to receive(:send_offer).once
             subject.handle_ami_event ami_event
           end
 
@@ -416,7 +423,7 @@ module Punchblock
             end
 
             it "should not create a new call" do
-              Asterisk::Call.should_receive(:new).never
+              expect(Asterisk::Call).to receive(:new).never
               subject.handle_ami_event ami_event
             end
           end
@@ -430,13 +437,13 @@ module Punchblock
             end
 
             it "should not create a new call" do
-              Asterisk::Call.should_receive(:new).never
+              expect(Asterisk::Call).to receive(:new).never
               subject.handle_ami_event ami_event
             end
 
             it 'should not be able to look up the call by channel ID' do
               subject.handle_ami_event ami_event
-              subject.call_for_channel('SIP/1234-00000000').should be nil
+              expect(subject.call_for_channel('SIP/1234-00000000')).to be nil
             end
           end
 
@@ -449,13 +456,13 @@ module Punchblock
             end
 
             it "should not create a new call" do
-              Asterisk::Call.should_receive(:new).never
+              expect(Asterisk::Call).to receive(:new).never
               subject.handle_ami_event ami_event
             end
 
             it 'should not be able to look up the call by channel ID' do
               subject.handle_ami_event ami_event
-              subject.call_for_channel('SIP/1234-00000000').should be nil
+              expect(subject.call_for_channel('SIP/1234-00000000')).to be nil
             end
           end
         end
@@ -472,7 +479,7 @@ module Punchblock
 
           before do
             ami_client.as_null_object
-            subject.wrapped_object.stub :handle_pb_event
+            allow(subject.wrapped_object).to receive :handle_pb_event
           end
 
           context "matching a call that was created by a Dial command" do
@@ -489,17 +496,17 @@ module Punchblock
 
             it "should set the correct channel on the call" do
               subject.handle_ami_event ami_event
-              call.channel.should be == 'SIP/1234-00000000'
+              expect(call.channel).to eq('SIP/1234-00000000')
             end
 
             it "should make it possible to look up the call by the full channel name" do
               subject.handle_ami_event ami_event
-              subject.call_for_channel("SIP/1234-00000000").should be call
+              expect(subject.call_for_channel("SIP/1234-00000000")).to be call
             end
 
             it "should make looking up the channel by the requested channel name impossible" do
               subject.handle_ami_event ami_event
-              subject.call_for_channel('SIP/1234').should be_nil
+              expect(subject.call_for_channel('SIP/1234')).to be_nil
             end
           end
 
@@ -507,7 +514,7 @@ module Punchblock
             let(:call_id) { 'foobarbaz' }
 
             it "should not raise" do
-              lambda { subject.handle_ami_event ami_event }.should_not raise_error
+              expect { subject.handle_ami_event ami_event }.not_to raise_error
             end
           end
         end
@@ -532,7 +539,7 @@ module Punchblock
           end
 
           it 'sends the AMI event to the call and to the connection as a PB event' do
-            call.should_receive(:process_ami_event).once.with ami_event
+            expect(call).to receive(:process_ami_event).once.with ami_event
             subject.handle_ami_event ami_event
           end
 
@@ -553,8 +560,8 @@ module Punchblock
               before { subject.register_call call2 }
 
               it 'should send the event to both calls and to the connection once as a PB event' do
-                call.should_receive(:process_ami_event).once.with ami_event
-                call2.should_receive(:process_ami_event).once.with ami_event
+                expect(call).to receive(:process_ami_event).once.with ami_event
+                expect(call2).to receive(:process_ami_event).once.with ami_event
                 subject.handle_ami_event ami_event
               end
             end
@@ -587,12 +594,12 @@ module Punchblock
           end
 
           it 'sends the AMI event to the call and to the connection as a PB event if it is an allowed event' do
-            call.should_receive(:process_ami_event).once.with ami_event
+            expect(call).to receive(:process_ami_event).once.with ami_event
             subject.handle_ami_event ami_event
           end
 
           it 'does not send the AMI event to a bridged channel if it is not allowed' do
-            call.should_receive(:process_ami_event).never.with ami_event2
+            expect(call).to receive(:process_ami_event).never.with ami_event2
             subject.handle_ami_event ami_event2
           end
 
@@ -611,29 +618,29 @@ module Punchblock
         end
 
         it 'should send the redirect extension Command to the AMI client' do
-          ami_client.should_receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
-          ami_client.should_receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
+          expect(ami_client).to receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
+          expect(ami_client).to receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
           subject.run_at_fully_booted
         end
 
         it 'should check the context for existence and do nothing if it is there' do
-          ami_client.should_receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
-          ami_client.should_receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
+          expect(ami_client).to receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
+          expect(ami_client).to receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
           subject.run_at_fully_booted
         end
 
         it 'should check the context for existence and log an error if it is not there' do
-          ami_client.should_receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
-          ami_client.should_receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(failed_show)
-          Punchblock.logger.should_receive(:error).once.with("Punchblock failed to add the #{Asterisk::REDIRECT_EXTENSION} extension to the #{Asterisk::REDIRECT_CONTEXT} context. Please add a [#{Asterisk::REDIRECT_CONTEXT}] entry to your dialplan.")
+          expect(ami_client).to receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
+          expect(ami_client).to receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(failed_show)
+          expect(Punchblock.logger).to receive(:error).once.with("Punchblock failed to add the #{Asterisk::REDIRECT_EXTENSION} extension to the #{Asterisk::REDIRECT_CONTEXT} context. Please add a [#{Asterisk::REDIRECT_CONTEXT}] entry to your dialplan.")
           subject.run_at_fully_booted
         end
 
         it 'should check the recording directory for existence' do
           stub_const('Punchblock::Translator::Asterisk::Component::Record::RECORDING_BASE_PATH', broken_path)
-          ami_client.should_receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
-          ami_client.should_receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
-          Punchblock.logger.should_receive(:warn).once.with("Recordings directory #{broken_path} does not exist. Recording might not work. This warning can be ignored if Adhearsion is running on a separate machine than Asterisk. See http://adhearsion.com/docs/call-controllers#recording")
+          expect(ami_client).to receive(:send_action).once.with 'Command', 'Command' => "dialplan add extension #{Asterisk::REDIRECT_EXTENSION},#{Asterisk::REDIRECT_PRIORITY},AGI,agi:async into #{Asterisk::REDIRECT_CONTEXT}"
+          expect(ami_client).to receive(:send_action).once.with('Command', 'Command' => "dialplan show #{Asterisk::REDIRECT_CONTEXT}").and_return(passed_show)
+          expect(Punchblock.logger).to receive(:warn).once.with("Recordings directory #{broken_path} does not exist. Recording might not work. This warning can be ignored if Adhearsion is running on a separate machine than Asterisk. See http://adhearsion.com/docs/call-controllers#recording")
           subject.run_at_fully_booted
         end
       end
@@ -642,7 +649,7 @@ module Punchblock
         let(:broken_path) { "/this/is/not/a/valid/path" }
         it 'logs a warning if the recording directory does not exist' do
           stub_const('Punchblock::Translator::Asterisk::Component::Record::RECORDING_BASE_PATH', broken_path)
-          Punchblock.logger.should_receive(:warn).once.with("Recordings directory #{broken_path} does not exist. Recording might not work. This warning can be ignored if Adhearsion is running on a separate machine than Asterisk. See http://adhearsion.com/docs/call-controllers#recording")
+          expect(Punchblock.logger).to receive(:warn).once.with("Recordings directory #{broken_path} does not exist. Recording might not work. This warning can be ignored if Adhearsion is running on a separate machine than Asterisk. See http://adhearsion.com/docs/call-controllers#recording")
           subject.check_recording_directory
         end
       end