adhearsion 2.6.4 → 3.0.0.beta1

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

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe ArrayMatchCalculator do
-
-        let(:match_payload) { :doesnt_matter }
-
-        it "matching arrays with fixnums" do
-          calculator = ArrayMatchCalculator.new [11,5,14,115], match_payload
-          match_case = calculator.match '11'
-          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'
-          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'
-          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'
-          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'
-          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'
-          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'
-          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'
-          expect(match_case).not_to be_exact_match
-          expect(match_case).not_to be_potential_match
-
-          expect(pattern).to eq([1,2,nil,5,10])
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe CalculatedMatchCollection do
-        def mock_with_potential_matches(potential_matches)
-          CalculatedMatch.new :potential_matches => potential_matches
-        end
-
-        def mock_with_exact_matches(exact_matches)
-          CalculatedMatch.new :exact_matches => exact_matches
-        end
-
-        def mock_with_potential_and_exact_matches(potential_matches, exact_matches)
-          CalculatedMatch.new :potential_matches => potential_matches,
-                              :exact_matches => exact_matches
-        end
-
-        it "the <<() method should collect the potential matches into the actual_potential_matches Array" do
-          mock_matches_array_1 = [:foo, :bar, :qaz],
-          mock_matches_array_2 = [10, 20, 30]
-          mock_matches_1 = mock_with_potential_matches mock_matches_array_1
-          mock_matches_2 = mock_with_potential_matches mock_matches_array_2
-
-          subject << mock_matches_1
-          expect(subject.actual_potential_matches).to eq(mock_matches_array_1)
-
-          subject << mock_matches_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
-          mock_matches_array_1 = [:blam, :blargh],
-          mock_matches_array_2 = [5,4,3,2,1]
-          mock_matches_1 = mock_with_exact_matches mock_matches_array_1
-          mock_matches_2 = mock_with_exact_matches mock_matches_array_2
-
-          subject << mock_matches_1
-          expect(subject.actual_exact_matches).to eq(mock_matches_array_1)
-
-          subject << mock_matches_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])
-          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])
-          expect(subject.potential_match?).to be true
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe CalculatedMatch do
-        it "should make accessible the context name" do
-          expect(CalculatedMatch.new(:match_payload => :foobar).match_payload).to be :foobar
-        end
-
-        it "should make accessible the original pattern" do
-          expect(CalculatedMatch.new(:pattern => :something).pattern).to be :something
-        end
-
-        it "should make accessible the matched query" do
-          expect(CalculatedMatch.new(:query => 123).query).to be 123
-        end
-
-        it "#type_of_match should return :exact, :potential, or nil" do
-          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
-          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
-          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
-          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
-          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
-          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
-          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
-  end
-end

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

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe FixnumMatchCalculator do
-        let(:match_payload) { :main }
-
-        it "a potential match scenario" do
-          calculator = FixnumMatchCalculator.new(444, match_payload)
-          match = calculator.match '4'
-          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'
-          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'
-          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)
-          expect(calculator.match('1337').match_payload).to be match_payload
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe MatchCalculator do
-        describe ".build_with_pattern" do
-          it "should return an appropriate subclass instance based on the pattern's class" do
-            expect(MatchCalculator.build_with_pattern(1..2, :main)).to be_an_instance_of RangeMatchCalculator
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,165 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-
-      describe MenuBuilder do
-        subject { MenuDSL::MenuBuilder.new }
-
-        describe "#build" do
-          it "sets the context and instance_eval's the block" do
-            expect(subject).to receive(:foo).with(:bar)
-            subject.build do
-              foo :bar
-            end
-          end
-
-          let(:foo) { :bar }
-
-          it "makes the block context available" do
-            doo = nil
-            subject.build do
-              doo = foo
-            end
-            expect(doo).to eq(:bar)
-          end
-        end#build
-
-        describe "#match" do
-          let(:match_block) { Proc.new() {} }
-
-          it "raises an exception if called without a CallController and no block" do
-            expect { subject.match 1 }.to raise_error(ArgumentError)
-          end
-
-          it "raises an exception if given both a payload and a block" do
-            expect { subject.match(1, Object) {} }.to raise_error(ArgumentError)
-          end
-
-          it "raises an exception if given no patterns" do
-            expect { subject.match() {} }.to raise_error(ArgumentError, "You cannot call this method without patterns.")
-          end
-
-          it "creates a pattern based on a payload" do
-            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
-            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
-            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
-            describe '#has_matchers?' do
-              it { expect(subject.has_matchers?).to be false }
-            end
-          end
-
-          context "with at least one matcher specified" do
-            before do
-              subject.match(1) {}
-            end
-
-            describe '#has_matchers?' do
-              it { expect(subject.has_matchers?).to be true }
-            end
-          end
-        end
-
-        describe "#weighted_match_calculators" do
-          let(:expected_pattern) { MenuDSL::MatchCalculator.build_with_pattern("1", Object) }
-
-          it "returns the generated patterns" do
-            expect(MenuDSL::MatchCalculator).to receive(:build_with_pattern).with("1", Object).at_least(:once).and_return(expected_pattern)
-            subject.match("1", Object)
-            expect(subject.weighted_match_calculators).to eq([expected_pattern])
-          end
-        end#weighted_match_calculators
-
-        describe "#invalid" do
-          let(:callback) { Proc.new() {} }
-
-          it "raises an error if not passed a block" do
-            expect { subject.invalid }.to raise_error(LocalJumpError)
-          end
-
-          it "sets the invalid callback" do
-            subject.invalid(&callback)
-            expect(subject.menu_callbacks[:invalid]).to eq(callback)
-          end
-        end#invalid
-
-        describe "#timeout" do
-          let(:callback) { Proc.new() {} }
-
-          it "raises an error if not passed a block" do
-            expect { subject.timeout }.to raise_error(LocalJumpError)
-          end
-
-          it "sets the timeout callback" do
-            subject.timeout(&callback)
-            expect(subject.menu_callbacks[:timeout]).to eq(callback)
-          end
-        end#timeout
-
-        describe "#failure" do
-          let(:callback) { Proc.new() {} }
-
-          it "raises an error if not passed a block" do
-            expect { subject.failure }.to raise_error(LocalJumpError)
-          end
-
-          it "sets the failure callback" do
-            subject.failure(&callback)
-            expect(subject.menu_callbacks[:failure]).to eq(callback)
-          end
-        end#failure
-
-        describe "#validator" do
-          let(:callback) { Proc.new() {} }
-
-          it "raises an error if not passed a block" do
-            expect { subject.validator }.to raise_error(LocalJumpError)
-          end
-
-          it "sets the invalid callback" do
-            subject.validator(&callback)
-            expect(subject.menu_callbacks[:validator]).to eq(callback)
-          end
-        end#invalid
-
-        describe "#execute_hook_for" do
-          it "executes the correct hook" do
-            bar = nil
-            subject.invalid do |baz|
-              bar = baz
-            end
-            subject.execute_hook_for(:invalid, "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)
-            expect(subject.calculate_matches_for("1")).to be_a CalculatedMatchCollection
-          end
-        end
-
-      end# describe MenuBuilder
-
-    end# module MenuDSL
-  end
-end

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

@@ -1,420 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    module MenuDSL
-      describe Menu do
-
-          let(:options) { Hash.new }
-          subject { Menu.new(options) }
-
-          describe "#initialize" do
-            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
-                expect(subject.timeout).to eq(5)
-              end
-            end
-
-            context 'when a timeout is set' do
-              let(:options) {
-                {:timeout => 20}
-              }
-
-              it 'should have the passed timeout' do
-                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
-                expect(subject.max_number_of_tries).to eq(1)
-              end
-            end
-
-            context 'when a max number of tries is set' do
-              let(:options) {
-                {:tries => 3}
-              }
-
-              it 'should have the passed max number of tries' do
-                expect(subject.max_number_of_tries).to eq(3)
-              end
-            end
-
-            context 'when no terminator is set' do
-              it "should have no terminator" do
-                expect(subject.terminator).to eq('')
-              end
-
-              it 'should not validate successfully' do
-                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
-              end
-            end
-
-            context 'when a terminator is set' do
-              let(:options) {
-                {:terminator => 3}
-              }
-
-              it 'should have the passed terminator' do
-                expect(subject.terminator).to eq('3')
-              end
-
-              it 'should validate(:basic) successfully' do
-                expect(subject.validate(:basic)).to be true
-              end
-
-              it 'should not validate successfully' do
-                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
-              end
-            end
-
-            context 'when no limit is set' do
-              it "should have no limit" do
-                expect(subject.limit).to be nil
-              end
-
-              it 'should not validate successfully' do
-                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
-              end
-            end
-
-            context 'when a limit is set' do
-              let(:options) {
-                {:limit => 3}
-              }
-
-              it 'should have the passed limit' do
-                expect(subject.limit).to eq(3)
-              end
-
-              it 'should validate(:basic) successfully' do
-                expect(subject.validate(:basic)).to be true
-              end
-
-              it 'should not validate successfully' do
-                expect { subject.validate }.to raise_error(Menu::InvalidStructureError)
-              end
-            end
-
-            context 'when no interruptibility is set' do
-              it "should be interruptible" do
-                expect(subject.interruptible).to be true
-              end
-            end
-
-            context 'when interruptible is set false' do
-              let(:options) {
-                {:interruptible => false}
-              }
-
-              it 'should be interruptible' do
-                expect(subject.interruptible).to be false
-              end
-            end
-
-            context 'when renderer is not specified' do
-              it 'should have a nil renderer' do
-                expect(subject.renderer).to be nil
-              end
-            end
-
-            context 'when renderer is specified' do
-              let(:options) {
-                {:renderer => :native}
-              }
-
-              it 'should have the specified renderer' do
-                expect(subject.renderer).to eq(:native)
-              end
-            end
-
-            context 'when matchers are specified' do
-              subject do
-                Menu.new do
-                  match(1) { }
-                end
-              end
-
-              it 'should validate successfully' do
-                expect(subject.validate).to be true
-              end
-
-              it 'should not validate(:basic) successfully' do
-                expect { subject.validate :basic }.to raise_error(Menu::InvalidStructureError)
-              end
-            end
-
-            context 'menu builder setup' do
-              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
-                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
-
-          end # describe #initialize
-
-          describe "#digit_buffer" do
-            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'
-              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
-              expect(subject.digit_buffer_empty?).to eq(true)
-            end
-
-            it "returns false if buffer is not empty" do
-              subject << 1
-              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
-              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
-              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
-
-          describe "#restart!" do
-            it "increments tries and clears the digit buffer" do
-              subject << 1
-              subject.restart!
-              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
-              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
-          end
-
-          describe "#execute_timeout_hook" do
-            it "calls the builder's execute_hook_for with :timeout" do
-              mock_menu_builder = MenuBuilder.new
-              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
-          end
-
-          describe "#execute_failure_hook" do
-            it "calls the builder's execute_hook_for with :failure" do
-              mock_menu_builder = MenuBuilder.new
-              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
-          end
-
-          describe "#execute_validator_hook" do
-            it "calls the builder's execute_hook_for with :validator" do
-              mock_menu_builder = MenuBuilder.new
-              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
-          end
-
-          describe "#continue" do
-            class MockControllerA; end
-            class MockControllerB; end
-            class MockControllerC; end
-            let(:options) { {} }
-            let(:menu_instance) {
-              Menu.new options do
-                match 1, MockControllerA
-                match 21, MockControllerA
-                match 23, MockControllerA
-                match 3, MockControllerB
-                match 3..5, MockControllerC
-                match 33, MockControllerA
-                match 6, MockControllerC
-                match 6..8, MockControllerA
-              end
-            }
-
-            it "returns a MenuGetAnotherDigitOrTimeout if the digit buffer is empty" do
-              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
-              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
-              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
-              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
-              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
-              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
-              let(:menu_instance) { Menu.new options }
-
-              context "when a terminator digit is set" do
-                let(:options) { { :terminator => '#' } }
-
-                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
-                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
-                  expect(menu_instance.status).to eq(:potential)
-                  menu_instance << '#'
-                  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
-
-              context "when a digit limit is set" do
-                let(:options) { { :limit => 3 } }
-
-                it "buffers until the limit is reached, then returns MenuLimitReached and sets the status to :limited" do
-                  menu_instance << 2
-                  menu_instance << 4
-                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
-                  expect(menu_instance.status).to eq(:potential)
-                  menu_instance << 2
-                  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
-
-              context "when a validator is defined" do
-                let(:menu_instance) do
-                  Menu.new options do
-                    validator { |buffer| buffer == "242" }
-                  end
-                end
-
-                it "buffers until the validator returns true, then returns MenuValidatorTerminated and sets the status to :validator_terminated" do
-                  menu_instance << 2
-                  menu_instance << 4
-                  expect(menu_instance.continue).to be_a Menu::MenuGetAnotherDigitOrTimeout
-                  expect(menu_instance.status).to eq(:potential)
-                  menu_instance << 2
-                  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
-
-              context "when a digit limit and validator is defined" do
-                let(:menu_instance) do
-                  Menu.new options.merge(:limit => 3) do
-                    validator { |buffer| buffer == "242" }
-                  end
-                end
-
-                it "applies the validator before checking the digit limit" do
-                  menu_instance << 2
-                  menu_instance << 4
-                  menu_instance << 2
-                  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
-
-          end#continue
-
-          describe Menu::ClearableStringBuffer do
-            subject { Menu::ClearableStringBuffer.new }
-
-            it "adds a string to itself" do
-              subject << 'b'
-              subject << 'c'
-              expect(subject).to eq('bc')
-            end
-
-            it "clears itself" do
-              subject << 'a'
-              subject.clear!
-              expect(subject).to eq("")
-            end
-          end
-
-      end # describe Menu
-    end
-  end
-end