adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/call_controller/input_spec.rb

@@ -16,22 +16,22 @@ module Adhearsion
         let(:sound_files) { [sound_file] }
 
         it "should play the sound files for the menu" do
-          subject.should_receive(:interruptible_play).with(sound_file, renderer_options).and_return("1")
-          subject.play_sound_files_for_menu(menu_instance, sound_files).should be == '1'
+          expect(subject).to receive(:interruptible_play).with(sound_file, renderer_options).and_return("1")
+          expect(subject.play_sound_files_for_menu(menu_instance, sound_files)).to eq('1')
         end
 
         it "should wait for digit if nothing is pressed during playback" do
-          subject.should_receive(:interruptible_play).with(sound_file, renderer_options).and_return(nil)
-          subject.should_receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
-          subject.play_sound_files_for_menu(menu_instance, sound_files).should be == '1'
+          expect(subject).to receive(:interruptible_play).with(sound_file, renderer_options).and_return(nil)
+          expect(subject).to receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
+          expect(subject.play_sound_files_for_menu(menu_instance, sound_files)).to eq('1')
         end
 
         context "with a renderer specified" do
           let(:options) { { :renderer => :native } }
           let(:renderer_options) { { renderer: :native } }
           it "should play the sound files for the menu" do
-            subject.should_receive(:interruptible_play).with(sound_file, renderer_options).and_return("1")
-            subject.play_sound_files_for_menu(menu_instance, sound_files).should be == '1'
+            expect(subject).to receive(:interruptible_play).with(sound_file, renderer_options).and_return("1")
+            expect(subject.play_sound_files_for_menu(menu_instance, sound_files)).to eq('1')
           end
 
         end
@@ -39,9 +39,9 @@ module Adhearsion
         context "when the menu is not interruptible" do
           let(:options) { { :interruptible => false } }
           it "should play the sound files and wait for digit" do
-            subject.should_receive(:play).with(sound_file, renderer_options).and_return true
-            subject.should_receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
-            subject.play_sound_files_for_menu(menu_instance, sound_files).should be == '1'
+            expect(subject).to receive(:play).with(sound_file, renderer_options).and_return true
+            expect(subject).to receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
+            expect(subject.play_sound_files_for_menu(menu_instance, sound_files)).to eq('1')
           end
         end
 
@@ -49,9 +49,9 @@ module Adhearsion
           let(:options) { { :renderer => :native, :interruptible => false } }
           let(:renderer_options) { { renderer: :native } }
           it "should pass the renderer option to #play" do
-            subject.should_receive(:play).with(sound_file, renderer_options).and_return true
-            subject.should_receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
-            subject.play_sound_files_for_menu(menu_instance, sound_files).should be == '1'
+            expect(subject).to receive(:play).with(sound_file, renderer_options).and_return true
+            expect(subject).to receive(:wait_for_digit).with(menu_instance.timeout).and_return("1")
+            expect(subject.play_sound_files_for_menu(menu_instance, sound_files)).to eq('1')
           end
         end
       end#play_sound_files_for_menu
@@ -92,14 +92,14 @@ module Adhearsion
 
         it "sends the correct input component" do
           expect_component_complete_event
-          subject.should_receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
+          expect(subject).to receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
           subject.wait_for_digit timeout
         end
 
         it "returns the correct pressed digit" do
           expect_component_complete_event
-          subject.should_receive(:execute_component_and_await_completion).once.with(kind_of(Punchblock::Component::Input)).and_return input_component
-          subject.wait_for_digit(timeout).should be == '5'
+          expect(subject).to receive(:execute_component_and_await_completion).once.with(kind_of(Punchblock::Component::Input)).and_return input_component
+          expect(subject.wait_for_digit(timeout)).to eq('5')
         end
 
         context "when the utterance does not have dtmf- prefix" do
@@ -107,8 +107,8 @@ module Adhearsion
 
           it "returns the correct pressed digit" do
             expect_component_complete_event
-            subject.should_receive(:execute_component_and_await_completion).once.with(kind_of(Punchblock::Component::Input)).and_return input_component
-            subject.wait_for_digit(timeout).should be == '5'
+            expect(subject).to receive(:execute_component_and_await_completion).once.with(kind_of(Punchblock::Component::Input)).and_return input_component
+            expect(subject.wait_for_digit(timeout)).to eq('5')
           end
         end
 
@@ -118,7 +118,7 @@ module Adhearsion
 
           it "does not set a timeout on the component" do
             expect_component_complete_event
-            subject.should_receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
+            expect(subject).to receive(:execute_component_and_await_completion).once.with(input_component).and_return input_component
             subject.wait_for_digit timeout
           end
         end
@@ -130,15 +130,15 @@ module Adhearsion
         let(:block) { Proc.new {} }
 
         it "calls instance_exec if the match object has a block" do
-          match_object.stub(:block => block)
-          subject.should_receive(:instance_exec).with(overrides[:extension], &block)
+          allow(match_object).to receive_messages(:block => block)
+          expect(subject).to receive(:instance_exec).with(overrides[:extension], &block)
           subject.jump_to(match_object, overrides)
         end
 
         it "calls invoke if the match object does not have a block" do
-          match_object.should_receive(:block).and_return(false)
-          match_object.should_receive(:match_payload).and_return(:payload)
-          subject.should_receive(:invoke).with(:payload, overrides)
+          expect(match_object).to receive(:block).and_return(false)
+          expect(match_object).to receive(:match_payload).and_return(:payload)
+          expect(subject).to receive(:invoke).with(:payload, overrides)
           subject.jump_to(match_object, overrides)
         end
       end#jump_to
@@ -162,91 +162,91 @@ module Adhearsion
         let(:response) { '1234' }
 
         before do
-          menu_instance.stub :status => status, :result => response
-          MenuDSL::Menu.should_receive(:new).and_return(menu_instance)
+          allow(menu_instance).to receive_messages :status => status, :result => response
+          expect(MenuDSL::Menu).to receive(:new).and_return(menu_instance)
         end
 
         it "logs a warning about dropped DTMF" do
-          menu_instance.should_receive(:continue).and_return(result_done)
+          expect(menu_instance).to receive(:continue).and_return(result_done)
 
-          call.logger.should_receive(:warn).with(/deprecated/)
+          expect(call.logger).to receive(:warn).with(/deprecated/)
           subject.menu sound_files
         end
 
         it "exits the function if MenuResultDone" do
-          menu_instance.should_receive(:should_continue?).and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_done)
+          expect(menu_instance).to receive(:should_continue?).and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_done)
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         it "exits the function if MenuTerminated" do
-          menu_instance.should_receive(:should_continue?).and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_terminated)
+          expect(menu_instance).to receive(:should_continue?).and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_terminated)
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         it "exits the function if MenuLimitReached" do
-          menu_instance.should_receive(:should_continue?).and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_limit_reached)
+          expect(menu_instance).to receive(:should_continue?).and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_limit_reached)
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         it "executes failure hook and returns :failure if menu fails" do
-          menu_instance.should_receive(:should_continue?).and_return(false)
-          menu_instance.should_receive(:execute_failure_hook).once
+          expect(menu_instance).to receive(:should_continue?).and_return(false)
+          expect(menu_instance).to receive(:execute_failure_hook).once
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         it "executes invalid hook if input is invalid" do
-          menu_instance.should_receive(:should_continue?).twice.and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_invalid, result_done)
-          menu_instance.should_receive(:execute_invalid_hook).once
-          menu_instance.should_receive(:restart!).once
+          expect(menu_instance).to receive(:should_continue?).twice.and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_invalid, result_done)
+          expect(menu_instance).to receive(:execute_invalid_hook).once
+          expect(menu_instance).to receive(:restart!).once
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         it "plays audio, then executes timeout hook if input times out" do
-          menu_instance.should_receive(:should_continue?).twice.and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
-          subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
-          menu_instance.should_receive(:execute_timeout_hook).once
-          menu_instance.should_receive(:restart!).once
+          expect(menu_instance).to receive(:should_continue?).twice.and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_get_another_or_timeout, result_done)
+          expect(subject).to receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
+          expect(menu_instance).to receive(:execute_timeout_hook).once
+          expect(menu_instance).to receive(:restart!).once
           subject.menu sound_files
         end
 
         it "plays audio, then adds digit to digit buffer if input is received" do
-          menu_instance.should_receive(:should_continue?).twice.and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
-          subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return("1")
-          menu_instance.should_receive(:<<).with("1").once
+          expect(menu_instance).to receive(:should_continue?).twice.and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_get_another_or_timeout, result_done)
+          expect(subject).to receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return("1")
+          expect(menu_instance).to receive(:<<).with("1").once
           subject.menu sound_files
         end
 
         it "plays audio, then jumps to payload when input is finished" do
-          menu_instance.should_receive(:should_continue?).and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_get_another_or_finish)
-          subject.should_receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
-          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension).once
+          expect(menu_instance).to receive(:should_continue?).and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_get_another_or_finish)
+          expect(subject).to receive(:play_sound_files_for_menu).with(menu_instance, sound_files).and_return(nil)
+          expect(subject).to receive(:jump_to).with(:match_object, :extension => :new_extension).once
           subject.menu sound_files
         end
 
         it "jumps to payload when result is found" do
-          menu_instance.should_receive(:should_continue?).and_return(true)
-          menu_instance.should_receive(:continue).and_return(result_found)
-          subject.should_receive(:jump_to).with(:match_object, :extension => :new_extension).once
+          expect(menu_instance).to receive(:should_continue?).and_return(true)
+          expect(menu_instance).to receive(:continue).and_return(result_found)
+          expect(subject).to receive(:jump_to).with(:match_object, :extension => :new_extension).once
           result = subject.menu sound_files
-          result.menu.should be menu_instance
-          result.response.should be response
+          expect(result.menu).to be menu_instance
+          expect(result.response).to be response
         end
 
         context "if a digit limit is specified" do
@@ -275,62 +275,62 @@ module Adhearsion
 
           before do
             menu_instance
-            MenuDSL::Menu.should_receive(:new).and_return(menu_instance)
+            expect(MenuDSL::Menu).to receive(:new).and_return(menu_instance)
           end
 
           it "logs a warning about dropped DTMF" do
-            menu_instance.should_receive(:continue).and_return(result_done)
+            expect(menu_instance).to receive(:continue).and_return(result_done)
 
-            call.logger.should_receive(:warn).with(/deprecated/)
+            expect(call.logger).to receive(:warn).with(/deprecated/)
             subject.ask sound_files
           end
 
           it "exits the function if MenuResultDone" do
-            menu_instance.should_receive(:continue).and_return(result_done)
+            expect(menu_instance).to receive(:continue).and_return(result_done)
             result = subject.ask sound_files
-            result.menu.should be menu_instance
-            result.response.should == ''
+            expect(result.menu).to be menu_instance
+            expect(result.response).to eq('')
           end
 
           it "exits the function if MenuTerminated" do
-            menu_instance.should_receive(:continue).and_return(result_terminated)
+            expect(menu_instance).to receive(:continue).and_return(result_terminated)
             result = subject.ask sound_files
-            result.menu.should be menu_instance
-            result.response.should == ''
+            expect(result.menu).to be menu_instance
+            expect(result.response).to eq('')
           end
 
           it "exits the function if MenuLimitReached" do
-            menu_instance.should_receive(:continue).and_return(result_limit_reached)
+            expect(menu_instance).to receive(:continue).and_return(result_limit_reached)
             result = subject.ask sound_files
-            result.menu.should be menu_instance
-            result.response.should == ''
+            expect(result.menu).to be menu_instance
+            expect(result.response).to eq('')
           end
 
           it "plays audio, then executes timeout hook if input times out" do
-            menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout)
-            subject.should_receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return(nil)
+            expect(menu_instance).to receive(:continue).and_return(result_get_another_or_timeout)
+            expect(subject).to receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return(nil)
             result = subject.ask sound_files
-            result.menu.should be menu_instance
-            result.response.should be == ''
-            result.status.should be :timeout
+            expect(result.menu).to be menu_instance
+            expect(result.response).to eq('')
+            expect(result.status).to be :timeout
           end
 
           it "plays audio, then adds digit to digit buffer if input is received" do
-            menu_instance.should_receive(:continue).and_return(result_get_another_or_timeout, result_done)
-            subject.should_receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return("1")
-            menu_instance.should_receive(:<<).with("1").once
+            expect(menu_instance).to receive(:continue).and_return(result_get_another_or_timeout, result_done)
+            expect(subject).to receive(:play_sound_files_for_menu).once.with(menu_instance, sound_files).and_return("1")
+            expect(menu_instance).to receive(:<<).with("1").once
             subject.ask sound_files
           end
         end
 
         context "with a block passed" do
           it "validates the buffer using that block, terminating on something truthy" do
-            subject.should_receive(:play_sound_files_for_menu).twice.and_return("1")
+            expect(subject).to receive(:play_sound_files_for_menu).twice.and_return("1")
             result = subject.ask sound_files, limit: 3 do |buffer|
               buffer == '11'
             end
-            result.status.should == :validator_terminated
-            result.response.should == '11'
+            expect(result.status).to eq(:validator_terminated)
+            expect(result.response).to eq('11')
           end
         end
 

data/spec/adhearsion/call_controller/menu_dsl/array_match_calculator_spec.rb

@@ -12,63 +12,63 @@ module Adhearsion
         it "matching arrays with fixnums" do
           calculator = ArrayMatchCalculator.new [11,5,14,115], match_payload
           match_case = calculator.match '11'
-          match_case.should be_exact_match
-          match_case.should be_potential_match
-          match_case.exact_matches.should be == [11]
-          match_case.potential_matches.should be == [115]
+          expect(match_case).to be_exact_match
+          expect(match_case).to be_potential_match
+          expect(match_case.exact_matches).to eq([11])
+          expect(match_case.potential_matches).to eq([115])
         end
 
         it "matching arrays with strings with digits and special digits" do
           calculator = ArrayMatchCalculator.new %w[*57 4 *54 115 ###], match_payload
           match_case = calculator.match '*5'
-          match_case.should_not be_exact_match
-          match_case.should be_potential_match
-          match_case.potential_matches.should be == %w[*57 *54]
+          expect(match_case).not_to be_exact_match
+          expect(match_case).to be_potential_match
+          expect(match_case.potential_matches).to eq(%w[*57 *54])
 
           match_case = calculator.match '*57'
-          match_case.should be_exact_match
-          match_case.should_not be_potential_match
-          match_case.exact_matches.should be == %w[*57]
+          expect(match_case).to be_exact_match
+          expect(match_case).not_to be_potential_match
+          expect(match_case.exact_matches).to eq(%w[*57])
         end
 
         it "matching an array with a combination of Fixnums and Strings" do
           calculator = ArrayMatchCalculator.new ['11',5,'14',115], match_payload
           match_case = calculator.match '11'
-          match_case.should be_exact_match
-          match_case.should be_potential_match
-          match_case.exact_matches.should be == ['11']
-          match_case.potential_matches.should be == [115]
+          expect(match_case).to be_exact_match
+          expect(match_case).to be_potential_match
+          expect(match_case.exact_matches).to eq(['11'])
+          expect(match_case.potential_matches).to eq([115])
         end
 
         it "matching empty array should never match" do
           calculator = ArrayMatchCalculator.new [], match_payload
           match_case = calculator.match '98'
-          match_case.should_not be_exact_match
-          match_case.should_not be_potential_match
-          match_case.exact_matches.should be == []
-          match_case.potential_matches.should be == []
+          expect(match_case).not_to be_exact_match
+          expect(match_case).not_to be_potential_match
+          expect(match_case.exact_matches).to eq([])
+          expect(match_case.potential_matches).to eq([])
 
           match_case = calculator.match '*2'
-          match_case.should_not be_exact_match
-          match_case.should_not be_potential_match
-          match_case.exact_matches.should be == []
-          match_case.potential_matches.should be == []
+          expect(match_case).not_to be_exact_match
+          expect(match_case).not_to be_potential_match
+          expect(match_case.exact_matches).to eq([])
+          expect(match_case.potential_matches).to eq([])
         end
 
         it "matching array with nil should skip nil field" do
           pattern = [1,2,nil,5,10]
           calculator = ArrayMatchCalculator.new pattern, match_payload
           match_case = calculator.match '1'
-          match_case.should be_exact_match
-          match_case.should be_potential_match
-          match_case.exact_matches.should be == [1]
-          match_case.potential_matches.should be == [10]
+          expect(match_case).to be_exact_match
+          expect(match_case).to be_potential_match
+          expect(match_case.exact_matches).to eq([1])
+          expect(match_case.potential_matches).to eq([10])
 
           match_case = calculator.match '99'
-          match_case.should_not be_exact_match
-          match_case.should_not be_potential_match
+          expect(match_case).not_to be_exact_match
+          expect(match_case).not_to be_potential_match
 
-          pattern.should == [1,2,nil,5,10]
+          expect(pattern).to eq([1,2,nil,5,10])
         end
       end
     end

data/spec/adhearsion/call_controller/menu_dsl/calculated_match_collection_spec.rb

@@ -26,10 +26,10 @@ module Adhearsion
           mock_matches_2 = mock_with_potential_matches mock_matches_array_2
 
           subject << mock_matches_1
-          subject.actual_potential_matches.should be == mock_matches_array_1
+          expect(subject.actual_potential_matches).to eq(mock_matches_array_1)
 
           subject << mock_matches_2
-          subject.actual_potential_matches.should be == mock_matches_array_1 + mock_matches_array_2
+          expect(subject.actual_potential_matches).to eq(mock_matches_array_1 + mock_matches_array_2)
         end
 
         it "the <<() method should collect the exact matches into the actual_exact_matches Array" do
@@ -39,20 +39,20 @@ module Adhearsion
           mock_matches_2 = mock_with_exact_matches mock_matches_array_2
 
           subject << mock_matches_1
-          subject.actual_exact_matches.should be == mock_matches_array_1
+          expect(subject.actual_exact_matches).to eq(mock_matches_array_1)
 
           subject << mock_matches_2
-          subject.actual_exact_matches.should be == mock_matches_array_1 + mock_matches_array_2
+          expect(subject.actual_exact_matches).to eq(mock_matches_array_1 + mock_matches_array_2)
         end
 
         it "if any exact matches exist, the exact_match?() method should return true" do
           subject << mock_with_exact_matches([1,2,3])
-          subject.exact_match?.should be true
+          expect(subject.exact_match?).to be true
         end
 
         it "if any potential matches exist, the potential_match?() method should return true" do
           subject << mock_with_potential_matches([1,2,3])
-          subject.potential_match?.should be true
+          expect(subject.potential_match?).to be true
         end
       end
     end