punchblock 2.5.2 → 2.5.3

data/spec/punchblock/translator/freeswitch/component/record_spec.rb

@@ -24,7 +24,7 @@ module Punchblock
 
           before do
             mock_stream.as_null_object
-            mock_call.stub(:uuid_foo)
+            allow(mock_call).to receive(:uuid_foo)
           end
 
           subject { Record.new original_command, mock_call }
@@ -39,12 +39,12 @@ module Punchblock
 
             it "sets command response to a reference to the component" do
               subject.execute
-              original_command.response(0.1).should be_a Ref
-              original_command.component_id.should be == subject.id
+              expect(original_command.response(0.1)).to be_a Ref
+              expect(original_command.component_id).to eq(subject.id)
             end
 
             it "starts a recording via uuid_record, using the component ID as the filename" do
-              mock_call.should_receive(:uuid_foo).once.with(:record, "start #{filename}")
+              expect(mock_call).to receive(:uuid_foo).once.with(:record, "start #{filename}")
               subject.execute
             end
 
@@ -56,37 +56,37 @@ module Punchblock
                 :record_file_path => filename
               }
               mock_call.handle_es_event record_stop_event
-              reason.should be_a Punchblock::Component::Record::Complete::MaxDuration
-              recording.uri.should be == full_filename
-              original_command.should be_complete
+              expect(reason).to be_a Punchblock::Component::Record::Complete::MaxDuration
+              expect(recording.uri).to eq(full_filename)
+              expect(original_command).to be_complete
             end
 
             describe 'start_paused' do
               context "set to nil" do
                 let(:command_options) { { :start_paused => nil } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to false" do
                 let(:command_options) { { :start_paused => false } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to true" do
                 let(:command_options) { { :start_paused => true } }
                 it "should return an error and not execute any actions" do
-                  mock_call.should_receive(:uuid_foo).never
+                  expect(mock_call).to receive(:uuid_foo).never
                   subject.execute
                   error = ProtocolError.new.setup 'option error', 'A start-paused value of true is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -95,30 +95,30 @@ module Punchblock
               context "set to nil" do
                 let(:command_options) { { :initial_timeout => nil } }
                 it "should setvar RECORD_INITIAL_TIMEOUT_MS with a 0 value" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to -1" do
                 let(:command_options) { { :initial_timeout => -1 } }
                 it "should setvar RECORD_INITIAL_TIMEOUT_MS with a 0 value" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to a positive number" do
                 let(:command_options) { { :initial_timeout => 10 } }
                 it "should setvar RECORD_INITIAL_TIMEOUT_MS with a value in ms" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 10").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 10").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
             end
@@ -127,30 +127,30 @@ module Punchblock
               context "set to nil" do
                 let(:command_options) { { :final_timeout => nil } }
                 it "should setvar RECORD_FINAL_TIMEOUT_MS with a 0 value" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to -1" do
                 let(:command_options) { { :final_timeout => -1 } }
                 it "should setvar RECORD_FINAL_TIMEOUT_MS with a 0 value" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to a positive number" do
                 let(:command_options) { { :final_timeout => 10 } }
                 it "should setvar RECORD_FINAL_TIMEOUT_MS with a value in ms" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 10").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 10").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
             end
@@ -159,40 +159,40 @@ module Punchblock
               context "set to nil" do
                 let(:command_options) { { :format => nil } }
                 it "should execute as 'wav'" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
 
                 it "provides the correct filename in the recording" do
-                  mock_call.should_receive(:uuid_foo)
+                  expect(mock_call).to receive(:uuid_foo)
                   subject.execute
                   record_stop_event = RubyFS::Event.new nil, {
                     :event_name       => 'RECORD_STOP',
                     :record_file_path => "#{Record::RECORDING_BASE_PATH}/#{subject.id}.wav"
                   }
                   mock_call.handle_es_event record_stop_event
-                  recording.uri.should match(/.*\.wav$/)
+                  expect(recording.uri).to match(/.*\.wav$/)
                 end
               end
 
               context "set to 'mp3'" do
                 let(:command_options) { { :format => 'mp3' } }
                 it "should execute as 'mp3'" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.mp3/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.mp3/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
 
                 it "provides the correct filename in the recording" do
-                  mock_call.should_receive(:uuid_foo)
+                  expect(mock_call).to receive(:uuid_foo)
                   subject.execute
                   record_stop_event = RubyFS::Event.new nil, {
                     :event_name       => 'RECORD_STOP',
                     :record_file_path => "#{Record::RECORDING_BASE_PATH}/#{subject.id}.mp3"
                   }
                   mock_call.handle_es_event record_stop_event
-                  recording.uri.should match(/.*\.mp3$/)
+                  expect(recording.uri).to match(/.*\.mp3$/)
                 end
               end
             end
@@ -201,18 +201,18 @@ module Punchblock
               context "set to nil" do
                 let(:command_options) { { :start_beep => nil } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to false" do
                 let(:command_options) { { :start_beep => false } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
@@ -220,10 +220,10 @@ module Punchblock
                 let(:command_options) { { :start_beep => true } }
 
                 it "should return an error and not execute any actions" do
-                  mock_call.should_receive(:uuid_foo).never
+                  expect(mock_call).to receive(:uuid_foo).never
                   subject.execute
                   error = ProtocolError.new.setup 'option error', 'A start-beep value of true is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -232,18 +232,18 @@ module Punchblock
               context "set to nil" do
                 let(:command_options) { { :max_duration => nil } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
               context "set to -1" do
                 let(:command_options) { { :max_duration => -1 } }
                 it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
 
@@ -253,7 +253,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   subject.execute
                   error = ProtocolError.new.setup 'option error', 'A max-duration value that is negative (and not -1) is invalid.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
 
@@ -263,9 +263,9 @@ module Punchblock
                 let(:command_options) { { :max_duration => 1000 } }
 
                 it "executes the recording with a time limit" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav 1$/)
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav 1$/)
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
             end
@@ -274,37 +274,37 @@ module Punchblock
               context "with nil" do
                 let(:command_options) { { :direction => nil } }
                 it "should execute the setvar application with duplex options before recording" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_STEREO true").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_STEREO true").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
               context "with :duplex" do
                 let(:command_options) { { :direction => :duplex } }
                 it "should execute the setvar application with duplex options before recording" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_STEREO true").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_STEREO true").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
               context "with :send" do
                 let(:command_options) { { :direction => :send } }
                 it "should execute the setvar application with send options before recording" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_WRITE_ONLY true").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_WRITE_ONLY true").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
               context "with :recv" do
                 let(:command_options) { { :direction => :recv } }
                 it "should execute the setvar application with recv options before recording" do
-                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_READ_ONLY true").ordered
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:setvar, "RECORD_READ_ONLY true").ordered
+                  expect(mock_call).to receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  original_command.response(0.1).should be_a Ref
+                  expect(original_command.response(0.1)).to be_a Ref
                 end
               end
             end
@@ -320,7 +320,7 @@ module Punchblock
               before { command.request! }
               it "returns a ProtocolError response" do
                 subject.execute_command command
-                command.response(0.1).should be_a ProtocolError
+                expect(command.response(0.1)).to be_a ProtocolError
               end
             end
 
@@ -342,24 +342,24 @@ module Punchblock
               end
 
               it "sets the command response to true" do
-                mock_call.should_receive :uuid_foo
+                expect(mock_call).to receive :uuid_foo
                 subject.execute_command command
                 send_stop_event
-                command.response(0.1).should be == true
+                expect(command.response(0.1)).to eq(true)
               end
 
               it "executes a uuid_record stop command" do
-                mock_call.should_receive(:uuid_foo).with(:record, "stop #{filename}")
+                expect(mock_call).to receive(:uuid_foo).with(:record, "stop #{filename}")
                 subject.execute_command command
               end
 
               it "sends the correct complete event" do
-                mock_call.should_receive(:uuid_foo).with(:record, "stop #{filename}")
+                expect(mock_call).to receive(:uuid_foo).with(:record, "stop #{filename}")
                 subject.execute_command command
                 send_stop_event
-                reason.should be_a Punchblock::Event::Complete::Stop
-                recording.uri.should be == "file://#{filename}"
-                original_command.should be_complete
+                expect(reason).to be_a Punchblock::Event::Complete::Stop
+                expect(recording.uri).to eq("file://#{filename}")
+                expect(original_command).to be_complete
               end
             end
 
@@ -368,7 +368,7 @@ module Punchblock
 
               before do
                 pending
-                mock_call.should_receive :uuid_foo
+                expect(mock_call).to receive :uuid_foo
                 command.request!
                 original_command.request!
                 subject.execute
@@ -376,11 +376,11 @@ module Punchblock
 
               it "sets the command response to true" do
                 subject.execute_command command
-                command.response(0.1).should be == true
+                expect(command.response(0.1)).to eq(true)
               end
 
               it "pauses the recording via AMI" do
-                mock_call.should_receive(:uuid_foo).once.with('PauseMonitor', 'Channel' => channel)
+                expect(mock_call).to receive(:uuid_foo).once.with('PauseMonitor', 'Channel' => channel)
                 subject.execute_command command
               end
             end
@@ -390,7 +390,7 @@ module Punchblock
 
               before do
                 pending
-                mock_call.should_receive :uuid_foo
+                expect(mock_call).to receive :uuid_foo
                 command.request!
                 original_command.request!
                 subject.execute
@@ -398,11 +398,11 @@ module Punchblock
 
               it "sets the command response to true" do
                 subject.execute_command command
-                command.response(0.1).should be == true
+                expect(command.response(0.1)).to eq(true)
               end
 
               it "resumes the recording via AMI" do
-                mock_call.should_receive(:uuid_foo).once.with('ResumeMonitor', 'Channel' => channel)
+                expect(mock_call).to receive(:uuid_foo).once.with('ResumeMonitor', 'Channel' => channel)
                 subject.execute_command command
               end
             end

data/spec/punchblock/translator/freeswitch/component/tts_output_spec.rb

@@ -35,7 +35,7 @@ module Punchblock
           describe '#execute' do
             before { original_command.request! }
             def expect_playback(voice = :kal, renderer = :flite, doc = ssml_doc)
-              subject.wrapped_object.should_receive(:application).once.with :speak, "#{renderer}|#{voice}|#{doc}"
+              expect(subject.wrapped_object).to receive(:application).once.with :speak, "#{renderer}|#{voice}|#{doc}"
             end
 
             let :ssml_doc do
@@ -61,7 +61,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'An SSML document is required.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
 
@@ -75,7 +75,7 @@ module Punchblock
                   expect_playback
                   execute
                   subject.handle_es_event RubyFS::Event.new(nil, :event_name => "CHANNEL_EXECUTE_COMPLETE")
-                  original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
+                  expect(original_command.complete_event(0.1).reason).to be_a Punchblock::Component::Output::Complete::Finish
                 end
               end
 
@@ -115,7 +115,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'A start_offset value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -134,7 +134,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'A start_paused value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -153,7 +153,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'A repeat_interval value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -172,7 +172,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'A repeat_times value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -191,7 +191,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'A max_time value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -228,7 +228,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'An interrupt-on value of any is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
 
@@ -237,7 +237,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'An interrupt-on value of dtmf is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
 
@@ -246,7 +246,7 @@ module Punchblock
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'An interrupt-on value of voice is unsupported.'
-                  original_command.response(0.1).should be == error
+                  expect(original_command.response(0.1)).to eq(error)
                 end
               end
             end
@@ -260,7 +260,7 @@ module Punchblock
 
               it "returns a ProtocolError response" do
                 subject.execute_command command
-                command.response(0.1).should be_a ProtocolError
+                expect(command.response(0.1)).to be_a ProtocolError
               end
             end
 
@@ -275,21 +275,21 @@ module Punchblock
               end
 
               it "sets the command response to true" do
-                subject.wrapped_object.should_receive(:application)
+                expect(subject.wrapped_object).to receive(:application)
                 subject.execute_command command
-                command.response(0.1).should be == true
+                expect(command.response(0.1)).to eq(true)
               end
 
               it "sends the correct complete event" do
-                subject.wrapped_object.should_receive(:application)
-                original_command.should_not be_complete
+                expect(subject.wrapped_object).to receive(:application)
+                expect(original_command).not_to be_complete
                 subject.execute_command command
-                reason.should be_a Punchblock::Event::Complete::Stop
-                original_command.should be_complete
+                expect(reason).to be_a Punchblock::Event::Complete::Stop
+                expect(original_command).to be_complete
               end
 
               it "breaks the current dialplan application" do
-                subject.wrapped_object.should_receive(:application).once.with 'break'
+                expect(subject.wrapped_object).to receive(:application).once.with 'break'
                 subject.execute_command command
               end
             end