adhearsion 2.5.4 → 2.6.0

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

@@ -7,53 +7,53 @@ module Adhearsion
     module MenuDSL
       describe CalculatedMatch do
         it "should make accessible the context name" do
-          CalculatedMatch.new(:match_payload => :foobar).match_payload.should be :foobar
+          expect(CalculatedMatch.new(:match_payload => :foobar).match_payload).to be :foobar
         end
 
         it "should make accessible the original pattern" do
-          CalculatedMatch.new(:pattern => :something).pattern.should be :something
+          expect(CalculatedMatch.new(:pattern => :something).pattern).to be :something
         end
 
         it "should make accessible the matched query" do
-          CalculatedMatch.new(:query => 123).query.should be 123
+          expect(CalculatedMatch.new(:query => 123).query).to be 123
         end
 
         it "#type_of_match should return :exact, :potential, or nil" do
-          CalculatedMatch.new(:potential_matches => [1]).type_of_match.should be :potential
-          CalculatedMatch.new(:exact_matches => [3,3]).type_of_match.should be :exact
-          CalculatedMatch.new(:exact_matches => [8,3], :potential_matches => [0,9]).type_of_match.should be :exact
+          expect(CalculatedMatch.new(:potential_matches => [1]).type_of_match).to be :potential
+          expect(CalculatedMatch.new(:exact_matches => [3,3]).type_of_match).to be :exact
+          expect(CalculatedMatch.new(:exact_matches => [8,3], :potential_matches => [0,9]).type_of_match).to be :exact
         end
 
         it "#exact_match? should return true if the match was exact" do
-          CalculatedMatch.new(:exact_matches => [0,3,5]).exact_match?.should be true
+          expect(CalculatedMatch.new(:exact_matches => [0,3,5]).exact_match?).to be true
         end
 
         it "#potential_match? should return true if the match was exact" do
-          CalculatedMatch.new(:potential_matches => [88,99,77]).potential_match?.should be true
+          expect(CalculatedMatch.new(:potential_matches => [88,99,77]).potential_match?).to be true
         end
 
         it "#failed_match? should return false if the match was exact" do
-          CalculatedMatch.new(:potential_matches => [88,99,77]).failed_match?.should be false
+          expect(CalculatedMatch.new(:potential_matches => [88,99,77]).failed_match?).to be false
         end
 
         it "#exact_matches should return an array of exact matches" do
-          CalculatedMatch.new(:exact_matches => [0,3,5]).exact_matches.should be == [0,3,5]
+          expect(CalculatedMatch.new(:exact_matches => [0,3,5]).exact_matches).to eq([0,3,5])
         end
 
         it "#potential_matches should return an array of potential matches" do
-          CalculatedMatch.new(:potential_matches => [88,99,77]).potential_matches.should be == [88,99,77]
+          expect(CalculatedMatch.new(:potential_matches => [88,99,77]).potential_matches).to eq([88,99,77])
         end
 
         it "::failed_match! should return a match that *really* failed" do
           failure = CalculatedMatch.failed_match! 10..20, 30, :match_payload_does_not_matter
-          failure.exact_match?.should_not be true
-          failure.potential_match?.should_not be true
-          failure.failed_match?.should be true
-          failure.type_of_match.should be nil
-
-          failure.match_payload.should be :match_payload_does_not_matter
-          failure.pattern.should be == (10..20)
-          failure.query.should be == 30
+          expect(failure.exact_match?).not_to be true
+          expect(failure.potential_match?).not_to be true
+          expect(failure.failed_match?).to be true
+          expect(failure.type_of_match).to be nil
+
+          expect(failure.match_payload).to be :match_payload_does_not_matter
+          expect(failure.pattern).to eq(10..20)
+          expect(failure.query).to eq(30)
         end
       end
     end

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

@@ -11,27 +11,27 @@ module Adhearsion
         it "a potential match scenario" do
           calculator = FixnumMatchCalculator.new(444, match_payload)
           match = calculator.match '4'
-          match.should be_potential_match
-          match.should_not be_exact_match
-          match.potential_matches.should be == [444]
+          expect(match).to be_potential_match
+          expect(match).not_to be_exact_match
+          expect(match.potential_matches).to eq([444])
         end
 
         it "a multi-digit exact match scenario" do
           calculator = FixnumMatchCalculator.new(5555, match_payload)
           match = calculator.match '5555'
-          match.should be_exact_match
+          expect(match).to be_exact_match
         end
 
         it "a single-digit exact match scenario" do
           calculator = FixnumMatchCalculator.new(1, match_payload)
           match = calculator.match '1'
-          match.should be_exact_match
+          expect(match).to be_exact_match
         end
 
         it "the context name given to the calculator should be passed on the CalculatedMatch" do
           match_payload = :icanhascheezburger
           calculator = FixnumMatchCalculator.new(1337, match_payload)
-          calculator.match('1337').match_payload.should be match_payload
+          expect(calculator.match('1337').match_payload).to be match_payload
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Adhearsion
       describe MatchCalculator do
         describe ".build_with_pattern" do
           it "should return an appropriate subclass instance based on the pattern's class" do
-            MatchCalculator.build_with_pattern(1..2, :main).should be_an_instance_of RangeMatchCalculator
+            expect(MatchCalculator.build_with_pattern(1..2, :main)).to be_an_instance_of RangeMatchCalculator
           end
         end
       end

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

@@ -7,11 +7,11 @@ module Adhearsion
     module MenuDSL
 
       describe MenuBuilder do
-        subject{ MenuDSL::MenuBuilder.new }
+        subject { MenuDSL::MenuBuilder.new }
 
         describe "#build" do
           it "sets the context and instance_eval's the block" do
-            subject.should_receive(:foo).with(:bar)
+            expect(subject).to receive(:foo).with(:bar)
             subject.build do
               foo :bar
             end
@@ -24,7 +24,7 @@ module Adhearsion
             subject.build do
               doo = foo
             end
-            doo.should == :bar
+            expect(doo).to eq(:bar)
           end
         end#build
 
@@ -44,25 +44,27 @@ module Adhearsion
           end
 
           it "creates a pattern based on a payload" do
-            MenuDSL::MatchCalculator.should_receive(:build_with_pattern).with("1", Object)
+            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with("1", Object)
             subject.match "1", Object
           end
 
           it "creates a pattern based on a block" do
-            MenuDSL::MatchCalculator.should_receive(:build_with_pattern).with("1", nil, &match_block)
+            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with("1", nil, &match_block)
             subject.match("1", &match_block)
           end
 
           it "creates multiple patterns if multiple arguments are passed in" do
-            MenuDSL::MatchCalculator.should_receive(:build_with_pattern).with(1, Object)
-            MenuDSL::MatchCalculator.should_receive(:build_with_pattern).with(2, Object)
+            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with(1, Object)
+            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with(2, Object)
             subject.match(1, 2, Object)
           end
         end#match
 
         describe "#has_matchers?" do
           context "with no matchers specified" do
-            its(:has_matchers?) { should be false }
+            describe '#has_matchers?' do
+              it { expect(subject.has_matchers?).to be false }
+            end
           end
 
           context "with at least one matcher specified" do
@@ -70,7 +72,9 @@ module Adhearsion
               subject.match(1) {}
             end
 
-            its(:has_matchers?) { should be true }
+            describe '#has_matchers?' do
+              it { expect(subject.has_matchers?).to be true }
+            end
           end
         end
 
@@ -78,9 +82,9 @@ module Adhearsion
           let(:expected_pattern) { MenuDSL::MatchCalculator.build_with_pattern("1", Object) }
 
           it "returns the generated patterns" do
-            MenuDSL::MatchCalculator.should_receive(:build_with_pattern).with("1", Object).at_least(:once).and_return(expected_pattern)
+            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with("1", Object).at_least(:once).and_return(expected_pattern)
             subject.match("1", Object)
-            subject.weighted_match_calculators.should be == [expected_pattern]
+            expect(subject.weighted_match_calculators).to eq([expected_pattern])
           end
         end#weighted_match_calculators
 
@@ -93,7 +97,7 @@ module Adhearsion
 
           it "sets the invalid callback" do
             subject.invalid(&callback)
-            subject.menu_callbacks[:invalid].should be == callback
+            expect(subject.menu_callbacks[:invalid]).to eq(callback)
           end
         end#invalid
 
@@ -106,7 +110,7 @@ module Adhearsion
 
           it "sets the timeout callback" do
             subject.timeout(&callback)
-            subject.menu_callbacks[:timeout].should be == callback
+            expect(subject.menu_callbacks[:timeout]).to eq(callback)
           end
         end#timeout
 
@@ -119,7 +123,7 @@ module Adhearsion
 
           it "sets the failure callback" do
             subject.failure(&callback)
-            subject.menu_callbacks[:failure].should be == callback
+            expect(subject.menu_callbacks[:failure]).to eq(callback)
           end
         end#failure
 
@@ -132,7 +136,7 @@ module Adhearsion
 
           it "sets the invalid callback" do
             subject.validator(&callback)
-            subject.menu_callbacks[:validator].should be == callback
+            expect(subject.menu_callbacks[:validator]).to eq(callback)
           end
         end#invalid
 
@@ -143,14 +147,14 @@ module Adhearsion
               bar = baz
             end
             subject.execute_hook_for(:invalid, "1")
-            bar.should be == "1"
+            expect(bar).to eq("1")
           end
         end#execute_hook_for
 
         describe "#calculate_matches_for" do
           it "returns a calculated match collection" do
             subject.match("1", Object)
-            subject.calculate_matches_for("1").should be_a CalculatedMatchCollection
+            expect(subject.calculate_matches_for("1")).to be_a CalculatedMatchCollection
           end
         end
 

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

@@ -11,11 +11,14 @@ module Adhearsion
           subject { Menu.new(options) }
 
           describe "#initialize" do
-            its(:tries_count) { should be == 0 }
+            describe '#tries_count' do
+              subject { super().tries_count }
+              it { is_expected.to eq(0) }
+            end
 
             context 'when no timeout is set' do
               it "should have the default timeout" do
-                subject.timeout.should be == 5
+                expect(subject.timeout).to eq(5)
               end
             end
 
@@ -25,13 +28,13 @@ module Adhearsion
               }
 
               it 'should have the passed timeout' do
-                subject.timeout.should be == 20
+                expect(subject.timeout).to eq(20)
               end
             end
 
             context 'when no max number of tries is set' do
               it "should have the default max number of tries" do
-                subject.max_number_of_tries.should be == 1
+                expect(subject.max_number_of_tries).to eq(1)
               end
             end
 
@@ -41,17 +44,17 @@ module Adhearsion
               }
 
               it 'should have the passed max number of tries' do
-                subject.max_number_of_tries.should be == 3
+                expect(subject.max_number_of_tries).to eq(3)
               end
             end
 
             context 'when no terminator is set' do
               it "should have no terminator" do
-                subject.terminator.should be == ''
+                expect(subject.terminator).to eq('')
               end
 
               it 'should not validate successfully' do
-                lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
               end
             end
 
@@ -61,25 +64,25 @@ module Adhearsion
               }
 
               it 'should have the passed terminator' do
-                subject.terminator.should be == '3'
+                expect(subject.terminator).to eq('3')
               end
 
               it 'should validate(:basic) successfully' do
-                subject.validate(:basic).should be true
+                expect(subject.validate(:basic)).to be true
               end
 
               it 'should not validate successfully' do
-                lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
               end
             end
 
             context 'when no limit is set' do
               it "should have no limit" do
-                subject.limit.should be nil
+                expect(subject.limit).to be nil
               end
 
               it 'should not validate successfully' do
-                lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
               end
             end
 
@@ -89,21 +92,21 @@ module Adhearsion
               }
 
               it 'should have the passed limit' do
-                subject.limit.should be == 3
+                expect(subject.limit).to eq(3)
               end
 
               it 'should validate(:basic) successfully' do
-                subject.validate(:basic).should be true
+                expect(subject.validate(:basic)).to be true
               end
 
               it 'should not validate successfully' do
-                lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
               end
             end
 
             context 'when no interruptibility is set' do
               it "should be interruptible" do
-                subject.interruptible.should be true
+                expect(subject.interruptible).to be true
               end
             end
 
@@ -113,13 +116,13 @@ module Adhearsion
               }
 
               it 'should be interruptible' do
-                subject.interruptible.should be false
+                expect(subject.interruptible).to be false
               end
             end
 
             context 'when renderer is not specified' do
               it 'should have a nil renderer' do
-                subject.renderer.should be nil
+                expect(subject.renderer).to be nil
               end
             end
 
@@ -129,7 +132,7 @@ module Adhearsion
               }
 
               it 'should have the specified renderer' do
-                subject.renderer.should == :native
+                expect(subject.renderer).to eq(:native)
               end
             end
 
@@ -141,21 +144,24 @@ module Adhearsion
               end
 
               it 'should validate successfully' do
-                subject.validate.should be true
+                expect(subject.validate).to be true
               end
 
               it 'should not validate(:basic) successfully' do
-                lambda { subject.validate :basic }.should raise_error(Menu::InvalidStructureError)
+                expect { subject.validate :basic }.to raise_error(Menu::InvalidStructureError)
               end
             end
 
             context 'menu builder setup' do
-              its(:builder) { should be_a MenuBuilder }
+              describe '#builder' do
+                subject { super().builder }
+                it { is_expected.to be_a MenuBuilder }
+              end
 
               it "should evaluate the block on the builder object" do
                 mock_menu_builder = MenuBuilder.new
-                MenuBuilder.should_receive(:new).and_return(mock_menu_builder)
-                mock_menu_builder.should_receive(:match).once.with(1)
+                expect(MenuBuilder).to receive(:new).and_return(mock_menu_builder)
+                expect(mock_menu_builder).to receive(:match).once.with(1)
                 Menu.new { match 1 }
               end
             end
@@ -163,41 +169,48 @@ module Adhearsion
           end # describe #initialize
 
           describe "#digit_buffer" do
-            its(:digit_buffer) { should be_a Menu::ClearableStringBuffer }
-            its(:digit_buffer) { should be == "" }
+            describe '#digit_buffer' do
+              subject { super().digit_buffer }
+              it { is_expected.to be_a Menu::ClearableStringBuffer }
+            end
+
+            describe '#digit_buffer' do
+              subject { super().digit_buffer }
+              it { is_expected.to eq("") }
+            end
           end
 
           describe "#<<" do
             it "should add a digit to the buffer" do
               subject << 'a'
-              subject.digit_buffer.should be == 'a'
-              subject.result.should be == 'a'
+              expect(subject.digit_buffer).to eq('a')
+              expect(subject.result).to eq('a')
             end
           end
 
           describe "#digit_buffer_empty?" do
             it "returns true if buffer is empty" do
-              subject.digit_buffer_empty?.should be == true
+              expect(subject.digit_buffer_empty?).to eq(true)
             end
 
             it "returns false if buffer is not empty" do
               subject << 1
-              subject.digit_buffer_empty?.should be == false
+              expect(subject.digit_buffer_empty?).to eq(false)
             end
           end
 
           describe "#digit_buffer_string" do
             it "returns the digit buffer as a string" do
               subject << 1
-              subject.digit_buffer_string.should be == "1"
+              expect(subject.digit_buffer_string).to eq("1")
             end
           end
 
           describe "#should_continue?" do
             it "returns true if the number of tries is less than the maximum" do
-              subject.max_number_of_tries.should be == 1
-              subject.tries_count.should be == 0
-              subject.should_continue?.should be == true
+              expect(subject.max_number_of_tries).to eq(1)
+              expect(subject.tries_count).to eq(0)
+              expect(subject.should_continue?).to eq(true)
             end
           end
 
@@ -205,16 +218,16 @@ module Adhearsion
             it "increments tries and clears the digit buffer" do
               subject << 1
               subject.restart!
-              subject.tries_count.should be == 1
-              subject.digit_buffer_empty?.should be == true
+              expect(subject.tries_count).to eq(1)
+              expect(subject.digit_buffer_empty?).to eq(true)
             end
           end
 
           describe "#execute_invalid_hook" do
             it "calls the builder's execute_hook_for with :invalid" do
               mock_menu_builder = MenuBuilder.new
-              MenuBuilder.should_receive(:new).and_return(mock_menu_builder)
-              mock_menu_builder.should_receive(:execute_hook_for).with(:invalid, "")
+              expect(MenuBuilder).to receive(:new).and_return(mock_menu_builder)
+              expect(mock_menu_builder).to receive(:execute_hook_for).with(:invalid, "")
               menu_instance = Menu.new
               menu_instance.execute_invalid_hook
             end
@@ -223,8 +236,8 @@ module Adhearsion
           describe "#execute_timeout_hook" do
             it "calls the builder's execute_hook_for with :timeout" do
               mock_menu_builder = MenuBuilder.new
-              MenuBuilder.should_receive(:new).and_return(mock_menu_builder)
-              mock_menu_builder.should_receive(:execute_hook_for).with(:timeout, "")
+              expect(MenuBuilder).to receive(:new).and_return(mock_menu_builder)
+              expect(mock_menu_builder).to receive(:execute_hook_for).with(:timeout, "")
               menu_instance = Menu.new
               menu_instance.execute_timeout_hook
             end
@@ -233,8 +246,8 @@ module Adhearsion
           describe "#execute_failure_hook" do
             it "calls the builder's execute_hook_for with :failure" do
               mock_menu_builder = MenuBuilder.new
-              MenuBuilder.should_receive(:new).and_return(mock_menu_builder)
-              mock_menu_builder.should_receive(:execute_hook_for).with(:failure, "")
+              expect(MenuBuilder).to receive(:new).and_return(mock_menu_builder)
+              expect(mock_menu_builder).to receive(:execute_hook_for).with(:failure, "")
               menu_instance = Menu.new
               menu_instance.execute_failure_hook
             end
@@ -243,8 +256,8 @@ module Adhearsion
           describe "#execute_validator_hook" do
             it "calls the builder's execute_hook_for with :validator" do
               mock_menu_builder = MenuBuilder.new
-              MenuBuilder.should_receive(:new).and_return(mock_menu_builder)
-              mock_menu_builder.should_receive(:execute_hook_for).with(:validator, "")
+              expect(MenuBuilder).to receive(:new).and_return(mock_menu_builder)
+              expect(mock_menu_builder).to receive(:execute_hook_for).with(:validator, "")
               menu_instance = Menu.new
               menu_instance.execute_validator_hook
             end
@@ -269,44 +282,44 @@ module Adhearsion
             }
 
             it "returns a MenuGetAnotherDigitOrTimeout if the digit buffer is empty" do
-              subject.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
-              menu_instance.status.should be nil
+              expect(subject.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
+              expect(menu_instance.status).to be nil
             end
 
             it "asks for another digit if it has potential matches" do
               menu_instance << 2
-              menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
-              menu_instance.status.should be == :potential
+              expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
+              expect(menu_instance.status).to eq(:potential)
             end
 
             it "returns a MenuResultInvalid if there are no matches" do
               menu_instance << 9
-              menu_instance.continue.should be_a Menu::MenuResultInvalid
-              menu_instance.status.should be == :invalid
+              expect(menu_instance.continue).to be_a Menu::MenuResultInvalid
+              expect(menu_instance.status).to eq(:invalid)
             end
 
             it "returns the first exact match when it has exact and potentials" do
               menu_instance << 3
               menu_result = menu_instance.continue
-              menu_result.should be_a Menu::MenuGetAnotherDigitOrFinish
-              menu_result.match_object.should be == MockControllerB
-              menu_result.new_extension.should be == "3"
-              menu_instance.status.should be == :multi_matched
+              expect(menu_result).to be_a Menu::MenuGetAnotherDigitOrFinish
+              expect(menu_result.match_object).to eq(MockControllerB)
+              expect(menu_result.new_extension).to eq("3")
+              expect(menu_instance.status).to eq(:multi_matched)
             end
 
             it "returns a MenuResultFound if it has exact matches" do
               menu_instance << 6
               menu_result = menu_instance.continue
-              menu_result.should be_a Menu::MenuResultFound
-              menu_instance.status.should be == :matched
+              expect(menu_result).to be_a Menu::MenuResultFound
+              expect(menu_instance.status).to eq(:matched)
             end
 
             it "returns the first exact match when it has only exact matches" do
               menu_instance << 6
               menu_result = menu_instance.continue
-              menu_result.should be_a Menu::MenuResultFound
-              menu_result.match_object.match_payload.should be == MockControllerC
-              menu_result.match_object.pattern.to_s.should be == "6"
+              expect(menu_result).to be_a Menu::MenuResultFound
+              expect(menu_result.match_object.match_payload).to eq(MockControllerC)
+              expect(menu_result.match_object.pattern.to_s).to eq("6")
             end
 
             context "with no matchers" do
@@ -318,13 +331,13 @@ module Adhearsion
                 it "buffers until the terminator is issued then returns a MenuTerminated and sets the status to :terminated, removing the terminator from the buffer" do
                   menu_instance << 2
                   menu_instance << 4
-                  menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
-                  menu_instance.status.should be == :potential
+                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
+                  expect(menu_instance.status).to eq(:potential)
                   menu_instance << '#'
-                  menu_instance.continue.should be_a Menu::MenuTerminated
-                  menu_instance.continue.should be_a Menu::MenuResultDone
-                  menu_instance.status.should be == :terminated
-                  menu_instance.result.should be == '24'
+                  expect(menu_instance.continue).to be_a Menu::MenuTerminated
+                  expect(menu_instance.continue).to be_a Menu::MenuResultDone
+                  expect(menu_instance.status).to eq(:terminated)
+                  expect(menu_instance.result).to eq('24')
                 end
               end
 
@@ -334,13 +347,13 @@ module Adhearsion
                 it "buffers until the limit is reached, then returns MenuLimitReached and sets the status to :limited" do
                   menu_instance << 2
                   menu_instance << 4
-                  menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
-                  menu_instance.status.should be == :potential
+                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
+                  expect(menu_instance.status).to eq(:potential)
                   menu_instance << 2
-                  menu_instance.continue.should be_a Menu::MenuLimitReached
-                  menu_instance.continue.should be_a Menu::MenuResultDone
-                  menu_instance.status.should be == :limited
-                  menu_instance.result.should be == '242'
+                  expect(menu_instance.continue).to be_a Menu::MenuLimitReached
+                  expect(menu_instance.continue).to be_a Menu::MenuResultDone
+                  expect(menu_instance.status).to eq(:limited)
+                  expect(menu_instance.result).to eq('242')
                 end
               end
 
@@ -354,13 +367,13 @@ module Adhearsion
                 it "buffers until the validator returns true, then returns MenuValidatorTerminated and sets the status to :validator_terminated" do
                   menu_instance << 2
                   menu_instance << 4
-                  menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
-                  menu_instance.status.should be == :potential
+                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
+                  expect(menu_instance.status).to eq(:potential)
                   menu_instance << 2
-                  menu_instance.continue.should be_a Menu::MenuValidatorTerminated
-                  menu_instance.continue.should be_a Menu::MenuResultDone
-                  menu_instance.status.should be == :validator_terminated
-                  menu_instance.result.should be == '242'
+                  expect(menu_instance.continue).to be_a Menu::MenuValidatorTerminated
+                  expect(menu_instance.continue).to be_a Menu::MenuResultDone
+                  expect(menu_instance.status).to eq(:validator_terminated)
+                  expect(menu_instance.result).to eq('242')
                 end
               end
 
@@ -375,10 +388,10 @@ module Adhearsion
                   menu_instance << 2
                   menu_instance << 4
                   menu_instance << 2
-                  menu_instance.continue.should be_a Menu::MenuValidatorTerminated
-                  menu_instance.continue.should be_a Menu::MenuResultDone
-                  menu_instance.status.should be == :validator_terminated
-                  menu_instance.result.should be == '242'
+                  expect(menu_instance.continue).to be_a Menu::MenuValidatorTerminated
+                  expect(menu_instance.continue).to be_a Menu::MenuResultDone
+                  expect(menu_instance.status).to eq(:validator_terminated)
+                  expect(menu_instance.result).to eq('242')
                 end
               end
             end
@@ -391,13 +404,13 @@ module Adhearsion
             it "adds a string to itself" do
               subject << 'b'
               subject << 'c'
-              subject.should be == 'bc'
+              expect(subject).to eq('bc')
             end
 
             it "clears itself" do
               subject << 'a'
               subject.clear!
-              subject.should be == ""
+              expect(subject).to eq("")
             end
           end